ZGlmZiAtLWdpdCBhLy5tYWlsbWFwIGIvLm1haWxtYXAKaW5kZXggZDM1N2UxYi4uMGQ5NzFjZiAxMDA2NDQKLS0tIGEvLm1haWxtYXAKKysrIGIvLm1haWxtYXAKQEAgLTczLDYgKzczLDcgQEAKIEp1aGEgWXJqb2xhIDxqdWhhLnlyam9sYUBzb2xpZGJvb3QuY29tPgogS2F5IFNpZXZlcnMgPGtheS5zaWV2ZXJzQHZyZnkub3JnPgogS2VubmV0aCBXIENoZW4gPGtlbm5ldGgudy5jaGVuQGludGVsLmNvbT4KK0tvbnN0YW50aW4gS2hsZWJuaWtvdiA8a29jdDlpQGdtYWlsLmNvbT4gPGsua2hsZWJuaWtvdkBzYW1zdW5nLmNvbT4KIEtvdXNoaWsgPHJhZ2hhdmVuZHJhLmtvdXNoaWtAbmV0ZXJpb24uY29tPgogS3VuaW5vcmkgTW9yaW1vdG8gPGt1bmlub3JpLm1vcmltb3RvLmd4QHJlbmVzYXMuY29tPgogTGVvbmlkIEkgQW5hbmlldiA8bGVvbmlkLmkuYW5hbmlldkBpbnRlbC5jb20+CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL0FCSS90ZXN0aW5nL3N5c2ZzLXBsYXRmb3JtLWRlbGwtbGFwdG9wIGIvRG9jdW1lbnRhdGlvbi9BQkkvdGVzdGluZy9zeXNmcy1wbGF0Zm9ybS1kZWxsLWxhcHRvcApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNzk2OTQ0My4uMDAwMDAwMAotLS0gYS9Eb2N1bWVudGF0aW9uL0FCSS90ZXN0aW5nL3N5c2ZzLXBsYXRmb3JtLWRlbGwtbGFwdG9wCisrKyAvZGV2L251bGwKQEAgLTEsNjAgKzAsMCBAQAotV2hhdDoJCS9zeXMvY2xhc3MvbGVkcy9kZWxsOjprYmRfYmFja2xpZ2h0L2Fsc19zZXR0aW5nCi1EYXRlOgkJRGVjZW1iZXIgMjAxNAotS2VybmVsVmVyc2lvbjoJMy4xOQotQ29udGFjdDoJR2FicmllbGUgTWF6em90dGEgPGdhYnJpZWxlLm16dEBnbWFpbC5jb20+LAotCQlQYWxpIFJvaMOhciA8cGFsaS5yb2hhckBnbWFpbC5jb20+Ci1EZXNjcmlwdGlvbjoKLQkJVGhpcyBmaWxlIGFsbG93cyB0byBjb250cm9sIHRoZSBhdXRvbWF0aWMga2V5Ym9hcmQKLQkJaWxsdW1pbmF0aW9uIG1vZGUgb24gc29tZSBzeXN0ZW1zIHRoYXQgaGF2ZSBhbiBhbWJpZW50Ci0JCWxpZ2h0IHNlbnNvci4gV3JpdGUgMSB0byB0aGlzIGZpbGUgdG8gZW5hYmxlIHRoZSBhdXRvCi0JCW1vZGUsIDAgdG8gZGlzYWJsZSBpdC4KLQotV2hhdDoJCS9zeXMvY2xhc3MvbGVkcy9kZWxsOjprYmRfYmFja2xpZ2h0L3N0YXJ0X3RyaWdnZXJzCi1EYXRlOgkJRGVjZW1iZXIgMjAxNAotS2VybmVsVmVyc2lvbjoJMy4xOQotQ29udGFjdDoJR2FicmllbGUgTWF6em90dGEgPGdhYnJpZWxlLm16dEBnbWFpbC5jb20+LAotCQlQYWxpIFJvaMOhciA8cGFsaS5yb2hhckBnbWFpbC5jb20+Ci1EZXNjcmlwdGlvbjoKLQkJVGhpcyBmaWxlIGFsbG93cyB0byBjb250cm9sIHRoZSBpbnB1dCB0cmlnZ2VycyB0aGF0Ci0JCXR1cm4gb24gdGhlIGtleWJvYXJkIGJhY2tsaWdodCBpbGx1bWluYXRpb24gdGhhdCBpcwotCQlkaXNhYmxlZCBiZWNhdXNlIG9mIGluYWN0aXZpdHkuCi0JCVJlYWQgdGhlIGZpbGUgdG8gc2VlIHRoZSB0cmlnZ2VycyBhdmFpbGFibGUuIFRoZSBvbmVzCi0JCWVuYWJsZWQgYXJlIHByZWNlZGVkIGJ5ICcrJywgdGhvc2UgZGlzYWJsZWQgYnkgJy0nLgotCi0JCVRvIGVuYWJsZSBhIHRyaWdnZXIsIHdyaXRlIGl0cyBuYW1lIHByZWNlZGVkIGJ5ICcrJyB0bwotCQl0aGlzIGZpbGUuIFRvIGRpc2FibGUgYSB0cmlnZ2VyLCB3cml0ZSBpdHMgbmFtZSBwcmVjZWRlZAotCQlieSAnLScgaW5zdGVhZC4KLQotCQlGb3IgZXhhbXBsZSwgdG8gZW5hYmxlIHRoZSBrZXlib2FyZCBhcyB0cmlnZ2VyIHJ1bjoKLQkJICAgIGVjaG8gK2tleWJvYXJkID4gL3N5cy9jbGFzcy9sZWRzL2RlbGw6OmtiZF9iYWNrbGlnaHQvc3RhcnRfdHJpZ2dlcnMKLQkJVG8gZGlzYWJsZSBpdDoKLQkJICAgIGVjaG8gLWtleWJvYXJkID4gL3N5cy9jbGFzcy9sZWRzL2RlbGw6OmtiZF9iYWNrbGlnaHQvc3RhcnRfdHJpZ2dlcnMKLQotCQlOb3RlIHRoYXQgbm90IGFsbCB0aGUgYXZhaWxhYmxlIHRyaWdnZXJzIGNhbiBiZSBjb25maWd1cmVkLgotCi1XaGF0OgkJL3N5cy9jbGFzcy9sZWRzL2RlbGw6OmtiZF9iYWNrbGlnaHQvc3RvcF90aW1lb3V0Ci1EYXRlOgkJRGVjZW1iZXIgMjAxNAotS2VybmVsVmVyc2lvbjoJMy4xOQotQ29udGFjdDoJR2FicmllbGUgTWF6em90dGEgPGdhYnJpZWxlLm16dEBnbWFpbC5jb20+LAotCQlQYWxpIFJvaMOhciA8cGFsaS5yb2hhckBnbWFpbC5jb20+Ci1EZXNjcmlwdGlvbjoKLQkJVGhpcyBmaWxlIGFsbG93cyB0byBzcGVjaWZ5IHRoZSBpbnRlcnZhbCBhZnRlciB3aGljaCB0aGUKLQkJa2V5Ym9hcmQgaWxsdW1pbmF0aW9uIGlzIGRpc2FibGVkIGJlY2F1c2Ugb2YgaW5hY3Rpdml0eS4KLQkJVGhlIHRpbWVvdXRzIGFyZSBleHByZXNzZWQgaW4gc2Vjb25kcywgbWludXRlcywgaG91cnMgYW5kCi0JCWRheXMsIGZvciB3aGljaCB0aGUgc3ltYm9scyBhcmUgJ3MnLCAnbScsICdoJyBhbmQgJ2QnCi0JCXJlc3BlY3RpdmVseS4KLQotCQlUbyBjb25maWd1cmUgdGhlIHRpbWVvdXQsIHdyaXRlIHRvIHRoaXMgZmlsZSBhIHZhbHVlIGFsb25nCi0JCXdpdGggYW55IHRoZSBhYm92ZSB1bml0cy4gSWYgbm8gdW5pdCBpcyBzcGVjaWZpZWQsIHRoZSB2YWx1ZQotCQlpcyBhc3N1bWVkIHRvIGJlIGV4cHJlc3NlZCBpbiBzZWNvbmRzLgotCi0JCUZvciBleGFtcGxlLCB0byBzZXQgdGhlIHRpbWVvdXQgdG8gMTAgbWludXRlcyBydW46Ci0JCSAgICBlY2hvIDEwbSA+IC9zeXMvY2xhc3MvbGVkcy9kZWxsOjprYmRfYmFja2xpZ2h0L3N0b3BfdGltZW91dAotCi0JCU5vdGUgdGhhdCB3aGVuIHRoaXMgZmlsZSBpcyByZWFkLCB0aGUgcmV0dXJuZWQgdmFsdWUgbWlnaHQgYmUKLQkJZXhwcmVzc2VkIGluIGEgZGlmZmVyZW50IHVuaXQgdGhhbiB0aGUgb25lIHVzZWQgd2hlbiB0aGUgdGltZW91dAotCQl3YXMgc2V0LgotCi0JCUFsc28gbm90ZSB0aGF0IG9ubHkgc29tZSB0aW1lb3V0cyBhcmUgc3VwcG9ydGVkIGFuZCB0aGF0Ci0JCXNvbWUgc3lzdGVtcyBtaWdodCBmYWxsIGJhY2sgdG8gYSBzcGVjaWZpYyB0aW1lb3V0IGluIGNhc2UKLQkJYW4gaW52YWxpZCB0aW1lb3V0IGlzIHdyaXR0ZW4gdG8gdGhpcyBmaWxlLgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9hY3BpL2VudW1lcmF0aW9uLnR4dCBiL0RvY3VtZW50YXRpb24vYWNwaS9lbnVtZXJhdGlvbi50eHQKaW5kZXggYjYwZDJhYi4uOWIxMjFhNSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9hY3BpL2VudW1lcmF0aW9uLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2FjcGkvZW51bWVyYXRpb24udHh0CkBAIC0yNDMsNyArMjQzLDcgQEAKIAkJCS5vd25lcgk9IFRISVNfTU9EVUxFLAogCQkJLnBtCT0gJm1wdTMwNTBfcG0sCiAJCQkub2ZfbWF0Y2hfdGFibGUgPSBtcHUzMDUwX29mX21hdGNoLAotCQkJLmFjcGlfbWF0Y2hfdGFibGUgIEFDUElfUFRSKG1wdTMwNTBfYWNwaV9tYXRjaCksCisJCQkuYWNwaV9tYXRjaF90YWJsZSA9IEFDUElfUFRSKG1wdTMwNTBfYWNwaV9tYXRjaCksCiAJCX0sCiAJCS5wcm9iZQkJPSBtcHUzMDUwX3Byb2JlLAogCQkucmVtb3ZlCQk9IG1wdTMwNTBfcmVtb3ZlLApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2FybS9hcm0tYm9hcmRzIGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2FybS9hcm0tYm9hcmRzCmluZGV4IDU1NmM4NjYuLmI3ODU2NGIyIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvYXJtL2FybS1ib2FyZHMKKysrIGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2FybS9hcm0tYm9hcmRzCkBAIC0yMyw3ICsyMyw3IEBACiAgICAgcmFuZ2Ugb2YgMHgyMDAgYnl0ZXMuCiAKIC0gc3lzY29uOiB0aGUgcm9vdCBub2RlIG9mIHRoZSBJbnRlZ3JhdG9yIHBsYXRmb3JtcyBtdXN0IGhhdmUgYQotICBzeXN0ZW0gY29udHJvbGxlciBub2RlIHBvaW50b25nIHRvIHRoZSBjb250cm9sIHJlZ2lzdGVycywKKyAgc3lzdGVtIGNvbnRyb2xsZXIgbm9kZSBwb2ludGluZyB0byB0aGUgY29udHJvbCByZWdpc3RlcnMsCiAgIHdpdGggdGhlIGNvbXBhdGlibGUgc3RyaW5nCiAgICJhcm0saW50ZWdyYXRvci1hcC1zeXNjb24iCiAgICJhcm0saW50ZWdyYXRvci1jcC1zeXNjb24iCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvYXJtL2Z3LWNmZy50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvYXJtL2Z3LWNmZy50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOTUzZmI2NAotLS0gL2Rldi9udWxsCisrKyBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9hcm0vZnctY2ZnLnR4dApAQCAtMCwwICsxLDcyIEBACisqIFFFTVUgRmlybXdhcmUgQ29uZmlndXJhdGlvbiBiaW5kaW5ncyBmb3IgQVJNCisKK1FFTVUncyBhcm0tc29mdG1tdSBhbmQgYWFyY2g2NC1zb2Z0bW11IGVtdWxhdGlvbiAvIHZpcnR1YWxpemF0aW9uIHRhcmdldHMKK3Byb3ZpZGUgdGhlIGZvbGxvd2luZyBGaXJtd2FyZSBDb25maWd1cmF0aW9uIGludGVyZmFjZSBvbiB0aGUgInZpcnQiIG1hY2hpbmUKK3R5cGU6CisKKy0gQSB3cml0ZS1vbmx5LCAxNi1iaXQgd2lkZSBzZWxlY3RvciAob3IgY29udHJvbCkgcmVnaXN0ZXIsCistIGEgcmVhZC13cml0ZSwgNjQtYml0IHdpZGUgZGF0YSByZWdpc3Rlci4KKworUUVNVSBleHBvc2VzIHRoZSBjb250cm9sIGFuZCBkYXRhIHJlZ2lzdGVyIHRvIEFSTSBndWVzdHMgYXMgbWVtb3J5IG1hcHBlZAorcmVnaXN0ZXJzOyB0aGVpciBsb2NhdGlvbiBpcyBjb21tdW5pY2F0ZWQgdG8gdGhlIGd1ZXN0J3MgVUVGSSBmaXJtd2FyZSBpbiB0aGUKK0RUQiB0aGF0IFFFTVUgcGxhY2VzIGF0IHRoZSBib3R0b20gb2YgdGhlIGd1ZXN0J3MgRFJBTS4KKworVGhlIGd1ZXN0IHdyaXRlcyBhIHNlbGVjdG9yIHZhbHVlIChhIGtleSkgdG8gdGhlIHNlbGVjdG9yIHJlZ2lzdGVyLCBhbmQgdGhlbgorY2FuIHJlYWQgdGhlIGNvcnJlc3BvbmRpbmcgZGF0YSAocHJvZHVjZWQgYnkgUUVNVSkgdmlhIHRoZSBkYXRhIHJlZ2lzdGVyLiBJZgordGhlIHNlbGVjdGVkIGVudHJ5IGlzIHdyaXRhYmxlLCB0aGUgZ3Vlc3QgY2FuIHJld3JpdGUgaXQgdGhyb3VnaCB0aGUgZGF0YQorcmVnaXN0ZXIuCisKK1RoZSBzZWxlY3RvciByZWdpc3RlciB0YWtlcyBrZXlzIGluIGJpZyBlbmRpYW4gYnl0ZSBvcmRlci4KKworVGhlIGRhdGEgcmVnaXN0ZXIgYWxsb3dzIGFjY2Vzc2VzIHdpdGggOCwgMTYsIDMyIGFuZCA2NC1iaXQgd2lkdGggKG9ubHkgYXQKK29mZnNldCAwIG9mIHRoZSByZWdpc3RlcikuIEFjY2Vzc2VzIGxhcmdlciB0aGFuIGEgYnl0ZSBhcmUgaW50ZXJwcmV0ZWQgYXMKK2FycmF5cywgYnVuZGxlZCB0b2dldGhlciBvbmx5IGZvciBiZXR0ZXIgcGVyZm9ybWFuY2UuIFRoZSBieXRlcyBjb25zdGl0dXRpbmcKK3N1Y2ggYSB3b3JkLCBpbiBpbmNyZWFzaW5nIGFkZHJlc3Mgb3JkZXIsIGNvcnJlc3BvbmQgdG8gdGhlIGJ5dGVzIHRoYXQgd291bGQKK2hhdmUgYmVlbiB0cmFuc2ZlcnJlZCBieSBieXRlLXdpZGUgYWNjZXNzZXMgaW4gY2hyb25vbG9naWNhbCBvcmRlci4KKworVGhlIGludGVyZmFjZSBhbGxvd3MgZ3Vlc3QgZmlybXdhcmUgdG8gZG93bmxvYWQgdmFyaW91cyBwYXJhbWV0ZXJzIGFuZCBibG9icwordGhhdCBhZmZlY3QgaG93IHRoZSBmaXJtd2FyZSB3b3JrcyBhbmQgd2hhdCB0YWJsZXMgaXQgaW5zdGFsbHMgZm9yIHRoZSBndWVzdAorT1MuIEZvciBleGFtcGxlLCBib290IG9yZGVyIG9mIGRldmljZXMsIEFDUEkgdGFibGVzLCBTTUJJT1MgdGFibGVzLCBrZXJuZWwgYW5kCitpbml0cmQgaW1hZ2VzIGZvciBkaXJlY3Qga2VybmVsIGJvb3RpbmcsIHZpcnR1YWwgbWFjaGluZSBVVUlELCBTTVAgaW5mb3JtYXRpb24sCit2aXJ0dWFsIE5VTUEgdG9wb2xvZ3ksIGFuZCBzbyBvbi4KKworVGhlIGF1dGhvcml0YXRpdmUgcmVnaXN0cnkgb2YgdGhlIHZhbGlkIHNlbGVjdG9yIHZhbHVlcyBhbmQgdGhlaXIgbWVhbmluZ3MgaXMKK3RoZSBRRU1VIHNvdXJjZSBjb2RlOyB0aGUgc3RydWN0dXJlIG9mIHRoZSBkYXRhIGJsb2JzIGNvcnJlc3BvbmRpbmcgdG8gdGhlCitpbmRpdmlkdWFsIGtleSB2YWx1ZXMgaXMgYWxzbyBkZWZpbmVkIGluIHRoZSBRRU1VIHNvdXJjZSBjb2RlLgorCitUaGUgcHJlc2VuY2Ugb2YgdGhlIHJlZ2lzdGVycyBjYW4gYmUgdmVyaWZpZWQgYnkgc2VsZWN0aW5nIHRoZSAic2lnbmF0dXJlIiBibG9iCit3aXRoIGtleSAweDAwMDAsIGFuZCByZWFkaW5nIGZvdXIgYnl0ZXMgZnJvbSB0aGUgZGF0YSByZWdpc3Rlci4gVGhlIHJldHVybmVkCitzaWduYXR1cmUgaXMgIlFFTVUiLgorCitUaGUgb3V0ZXJtb3N0IHByb3RvY29sIChpbnZvbHZpbmcgdGhlIHdyaXRlIC8gcmVhZCBzZXF1ZW5jZXMgb2YgdGhlIGNvbnRyb2wgYW5kCitkYXRhIHJlZ2lzdGVycykgaXMgZXhwZWN0ZWQgdG8gYmUgdmVyc2lvbmVkLCBhbmQvb3IgZGVzY3JpYmVkIGJ5IGZlYXR1cmUgYml0cy4KK1RoZSBpbnRlcmZhY2UgcmV2aXNpb24gLyBmZWF0dXJlIGJpdG1hcCBjYW4gYmUgcmV0cmlldmVkIHdpdGgga2V5IDB4MDAwMS4gVGhlCitibG9iIHRvIGJlIHJlYWQgZnJvbSB0aGUgZGF0YSByZWdpc3RlciBoYXMgc2l6ZSA0LCBhbmQgaXQgaXMgdG8gYmUgaW50ZXJwcmV0ZWQKK2FzIGEgdWludDMyX3QgdmFsdWUgaW4gbGl0dGxlIGVuZGlhbiBieXRlIG9yZGVyLiBUaGUgY3VycmVudCB2YWx1ZQorKGNvcnJlc3BvbmRpbmcgdG8gdGhlIGFib3ZlIG91dGVyIHByb3RvY29sKSBpcyB6ZXJvLgorCitUaGUgZ3Vlc3Qga2VybmVsIGlzIG5vdCBleHBlY3RlZCB0byB1c2UgdGhlc2UgcmVnaXN0ZXJzIChhbHRob3VnaCBpdCBpcworY2VydGFpbmx5IGFsbG93ZWQgdG8pOyB0aGUgZGV2aWNlIHRyZWUgYmluZGluZ3MgYXJlIGRvY3VtZW50ZWQgaGVyZSBiZWNhdXNlCit0aGlzIGlzIHdoZXJlIGRldmljZSB0cmVlIGJpbmRpbmdzIHJlc2lkZSBpbiBnZW5lcmFsLgorCitSZXF1aXJlZCBwcm9wZXJ0aWVzOgorCistIGNvbXBhdGlibGU6ICJxZW11LGZ3LWNmZy1tbWlvIi4KKworLSByZWc6IHRoZSBNTUlPIHJlZ2lvbiB1c2VkIGJ5IHRoZSBkZXZpY2UuCisgICogQnl0ZXMgMHgwIHRvIDB4NyBjb3ZlciB0aGUgZGF0YSByZWdpc3Rlci4KKyAgKiBCeXRlcyAweDggdG8gMHg5IGNvdmVyIHRoZSBzZWxlY3RvciByZWdpc3Rlci4KKyAgKiBGdXJ0aGVyIHJlZ2lzdGVycyBtYXkgYmUgYXBwZW5kZWQgdG8gdGhlIHJlZ2lvbiBpbiBjYXNlIG9mIGZ1dHVyZSBpbnRlcmZhY2UKKyAgICByZXZpc2lvbnMgLyBmZWF0dXJlIGJpdHMuCisKK0V4YW1wbGU6CisKKy8geworCSNzaXplLWNlbGxzID0gPDB4Mj47CisJI2FkZHJlc3MtY2VsbHMgPSA8MHgyPjsKKworCWZ3LWNmZ0A5MDIwMDAwIHsKKwkJY29tcGF0aWJsZSA9ICJxZW11LGZ3LWNmZy1tbWlvIjsKKwkJcmVnID0gPDB4MCAweDkwMjAwMDAgMHgwIDB4YT47CisJfTsKK307CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvZGV2ZnJlcS9ldmVudC9leHlub3MtcHBtdS50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvZGV2ZnJlcS9ldmVudC9leHlub3MtcHBtdS50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYjU0YmYzYQotLS0gL2Rldi9udWxsCisrKyBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9kZXZmcmVxL2V2ZW50L2V4eW5vcy1wcG11LnR4dApAQCAtMCwwICsxLDExMCBAQAorCisqIFNhbXN1bmcgRXh5bm9zIFBQTVUgKFBsYXRmb3JtIFBlcmZvcm1hbmNlIE1vbml0b3JpbmcgVW5pdCkgZGV2aWNlCisKK1RoZSBTYW1zdW5nIEV4eW5vcyBTb0MgaGFzIFBQTVUgKFBsYXRmb3JtIFBlcmZvcm1hbmNlIE1vbml0b3JpbmcgVW5pdCkgZm9yCitlYWNoIElQLiBQUE1VIHByb3ZpZGVzIHRoZSBwcmltaXRpdmUgdmFsdWVzIHRvIGdldCBwZXJmb3JtYW5jZSBkYXRhLiBUaGVzZQorUFBNVSBldmVudHMgcHJvdmlkZSBpbmZvcm1hdGlvbiBvZiB0aGUgU29DJ3MgYmVoYXZpb3JzIHNvIHRoYXQgeW91IG1heQordXNlIHRvIGFuYWx5emUgc3lzdGVtIHBlcmZvcm1hbmNlLCB0byBtYWtlIGJlaGF2aW9ycyB2aXNpYmxlIGFuZCB0byBjb3VudAordXNhZ2VzIG9mIGVhY2ggSVAgKERNQywgQ1BVLCBSSUdIVEJVUywgTEVGVEJVUywgQ0FNIGludGVyZmFjZSwgTENELCBHM0QsIE1GQykuCitUaGUgRXh5bm9zIFBQTVUgZHJpdmVyIHVzZXMgdGhlIGRldmZyZXEtZXZlbnQgY2xhc3MgdG8gcHJvdmlkZSBldmVudCBkYXRhCit0byB2YXJpb3VzIGRldmZyZXEgZGV2aWNlcy4gVGhlIGRldmZyZXEgZGV2aWNlcyB3b3VsZCB1c2UgdGhlIGV2ZW50IGRhdGEgd2hlbgorZGVydGVybWluZyB0aGUgY3VycmVudCBzdGF0ZSBvZiBlYWNoIElQLgorCitSZXF1aXJlZCBwcm9wZXJ0aWVzOgorLSBjb21wYXRpYmxlOiBTaG91bGQgYmUgInNhbXN1bmcsZXh5bm9zLXBwbXUiLgorLSByZWc6IHBoeXNpY2FsIGJhc2UgYWRkcmVzcyBvZiBlYWNoIFBQTVUgYW5kIGxlbmd0aCBvZiBtZW1vcnkgbWFwcGVkIHJlZ2lvbi4KKworT3B0aW9uYWwgcHJvcGVydGllczoKKy0gY2xvY2stbmFtZXMgOiB0aGUgbmFtZSBvZiBjbG9jayB1c2VkIGJ5IHRoZSBQUE1VLCAicHBtdSIKKy0gY2xvY2tzIDogcGhhbmRsZXMgZm9yIGNsb2NrIHNwZWNpZmllZCBpbiAiY2xvY2stbmFtZXMiIHByb3BlcnR5CistICNjbG9jay1jZWxsczogc2hvdWxkIGJlIDEuCisKK0V4YW1wbGUxIDogUFBNVSBub2RlcyBpbiBleHlub3MzMjUwLmR0c2kgYXJlIGxpc3RlZCBiZWxvdy4KKworCQlwcG11X2RtYzA6IHBwbXVfZG1jMEAxMDZhMDAwMCB7CisJCQljb21wYXRpYmxlID0gInNhbXN1bmcsZXh5bm9zLXBwbXUiOworCQkJcmVnID0gPDB4MTA2YTAwMDAgMHgyMDAwPjsKKwkJCXN0YXR1cyA9ICJkaXNhYmxlZCI7CisJCX07CisKKwkJcHBtdV9kbWMxOiBwcG11X2RtYzFAMTA2YjAwMDAgeworCQkJY29tcGF0aWJsZSA9ICJzYW1zdW5nLGV4eW5vcy1wcG11IjsKKwkJCXJlZyA9IDwweDEwNmIwMDAwIDB4MjAwMD47CisJCQlzdGF0dXMgPSAiZGlzYWJsZWQiOworCQl9OworCisJCXBwbXVfY3B1OiBwcG11X2NwdUAxMDZjMDAwMCB7CisJCQljb21wYXRpYmxlID0gInNhbXN1bmcsZXh5bm9zLXBwbXUiOworCQkJcmVnID0gPDB4MTA2YzAwMDAgMHgyMDAwPjsKKwkJCXN0YXR1cyA9ICJkaXNhYmxlZCI7CisJCX07CisKKwkJcHBtdV9yaWdodGJ1czogcHBtdV9yaWdodGJ1c0AxMTJhMDAwMCB7CisJCQljb21wYXRpYmxlID0gInNhbXN1bmcsZXh5bm9zLXBwbXUiOworCQkJcmVnID0gPDB4MTEyYTAwMDAgMHgyMDAwPjsKKwkJCWNsb2NrcyA9IDwmY211IENMS19QUE1VUklHSFQ+OworCQkJY2xvY2stbmFtZXMgPSAicHBtdSI7CisJCQlzdGF0dXMgPSAiZGlzYWJsZWQiOworCQl9OworCisJCXBwbXVfbGVmdGJ1czogcHBtdV9sZWZ0YnVzMEAxMTZhMDAwMCB7CisJCQljb21wYXRpYmxlID0gInNhbXN1bmcsZXh5bm9zLXBwbXUiOworCQkJcmVnID0gPDB4MTE2YTAwMDAgMHgyMDAwPjsKKwkJCWNsb2NrcyA9IDwmY211IENMS19QUE1VTEVGVD47CisJCQljbG9jay1uYW1lcyA9ICJwcG11IjsKKwkJCXN0YXR1cyA9ICJkaXNhYmxlZCI7CisJCX07CisKK0V4YW1wbGUyIDogRXZlbnRzIG9mIGVhY2ggUFBNVSBub2RlIGluIGV4eW5vczMyNTAtcmluYXRvLmR0cyBhcmUgbGlzdGVkIGJlbG93LgorCisJJnBwbXVfZG1jMCB7CisJCXN0YXR1cyA9ICJva2F5IjsKKworCQlldmVudHMgeworCQkJcHBtdV9kbWMwXzM6IHBwbXUtZXZlbnQzLWRtYzAgeworCQkJCWV2ZW50LW5hbWUgPSAicHBtdS1ldmVudDMtZG1jMCI7CisJCQl9OworCisJCQlwcG11X2RtYzBfMjogcHBtdS1ldmVudDItZG1jMCB7CisJCQkJZXZlbnQtbmFtZSA9ICJwcG11LWV2ZW50Mi1kbWMwIjsKKwkJCX07CisKKwkJCXBwbXVfZG1jMF8xOiBwcG11LWV2ZW50MS1kbWMwIHsKKwkJCQlldmVudC1uYW1lID0gInBwbXUtZXZlbnQxLWRtYzAiOworCQkJfTsKKworCQkJcHBtdV9kbWMwXzA6IHBwbXUtZXZlbnQwLWRtYzAgeworCQkJCWV2ZW50LW5hbWUgPSAicHBtdS1ldmVudDAtZG1jMCI7CisJCQl9OworCQl9OworCX07CisKKwkmcHBtdV9kbWMxIHsKKwkJc3RhdHVzID0gIm9rYXkiOworCisJCWV2ZW50cyB7CisJCQlwcG11X2RtYzFfMzogcHBtdS1ldmVudDMtZG1jMSB7CisJCQkJZXZlbnQtbmFtZSA9ICJwcG11LWV2ZW50My1kbWMxIjsKKwkJCX07CisJCX07CisJfTsKKworCSZwcG11X2xlZnRidXMgeworCQlzdGF0dXMgPSAib2theSI7CisKKwkJZXZlbnRzIHsKKwkJCXBwbXVfbGVmdGJ1c18zOiBwcG11LWV2ZW50My1sZWZ0YnVzIHsKKwkJCQlldmVudC1uYW1lID0gInBwbXUtZXZlbnQzLWxlZnRidXMiOworCQkJfTsKKwkJfTsKKwl9OworCisJJnBwbXVfcmlnaHRidXMgeworCQlzdGF0dXMgPSAib2theSI7CisKKwkJZXZlbnRzIHsKKwkJCXBwbXVfcmlnaHRidXNfMzogcHBtdS1ldmVudDMtcmlnaHRidXMgeworCQkJCWV2ZW50LW5hbWUgPSAicHBtdS1ldmVudDMtcmlnaHRidXMiOworCQkJfTsKKwkJfTsKKwl9OwpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2dyYXBoLnR4dCBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9ncmFwaC50eHQKaW5kZXggMWE2OWMwNy4uZmNiMWM2YSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2dyYXBoLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvZ3JhcGgudHh0CkBAIC0xOSw3ICsxOSw3IEBACiBtYXkgYmUgZGVzY3JpYmVkIGJ5IHNwZWNpYWxpemVkIGJpbmRpbmdzIGRlcGVuZGluZyBvbiB0aGUgdHlwZSBvZiBjb25uZWN0aW9uLgogCiBUbyBzZWUgaG93IHRoaXMgYmluZGluZyBhcHBsaWVzIHRvIHZpZGVvIHBpcGVsaW5lcywgZm9yIGV4YW1wbGUsIHNlZQotRG9jdW1lbnRhdGlvbi9kZXZpY2UtdHJlZS9iaW5kaW5ncy9tZWRpYS92aWRlby1pbnRlcmZhY2VzLnR4dC4KK0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9tZWRpYS92aWRlby1pbnRlcmZhY2VzLnR4dC4KIEhlcmUgdGhlIHBvcnRzIGRlc2NyaWJlIGRhdGEgaW50ZXJmYWNlcywgYW5kIHRoZSBsaW5rcyBiZXR3ZWVuIHRoZW0gYXJlCiB0aGUgY29ubmVjdGluZyBkYXRhIGJ1c2VzLiBBIHNpbmdsZSBwb3J0IHdpdGggbXVsdGlwbGUgY29ubmVjdGlvbnMgY2FuCiBjb3JyZXNwb25kIHRvIG11bHRpcGxlIGRldmljZXMgYmVpbmcgY29ubmVjdGVkIHRvIHRoZSBzYW1lIHBoeXNpY2FsIGJ1cy4KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9pMmMvaTJjLXN0LnR4dCBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9pMmMvaTJjLXN0LnR4dAppbmRleCA0MzdlMGRiLi40YzI2ZmRhIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvaTJjL2kyYy1zdC50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2kyYy9pMmMtc3QudHh0CkBAIC0zMSw3ICszMSw3IEBACiAJY29tcGF0aWJsZQk9ICJzdCxjb21tcy1zc2M0LWkyYyI7CiAJcmVnCQk9IDwweGZlZDQwMDAwIDB4MTEwPjsKIAlpbnRlcnJ1cHRzCT0gIDxHSUNfU1BJIDE4NyBJUlFfVFlQRV9MRVZFTF9ISUdIPjsKLQljbG9ja3MJCT0gPCZDTEtfU19JQ05fUkVHXzA+OworCWNsb2NrcwkJPSA8JmNsa19zX2EwX2xzIENMS19JQ05fUkVHPjsKIAljbG9jay1uYW1lcwk9ICJzc2MiOwogCWNsb2NrLWZyZXF1ZW5jeSA9IDw0MDAwMDA+OwogCXBpbmN0cmwtbmFtZXMJPSAiZGVmYXVsdCI7CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvaTJjL3RyaXZpYWwtZGV2aWNlcy50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvaTJjL3RyaXZpYWwtZGV2aWNlcy50eHQKaW5kZXggOWY0ZTM4Mi4uOWY0MWQwNSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2kyYy90cml2aWFsLWRldmljZXMudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9pMmMvdHJpdmlhbC1kZXZpY2VzLnR4dApAQCAtNDcsNiArNDcsNyBAQAogZGFsbGFzLGRzNDUxMAkJQ1BVIFN1cGVydmlzb3Igd2l0aCBOb252b2xhdGlsZSBNZW1vcnkgYW5kIFByb2dyYW1tYWJsZSBJL08KIGRhbGxhcyxkczc1CQlEaWdpdGFsIFRoZXJtb21ldGVyIGFuZCBUaGVybW9zdGF0CiBkbGcsZGE5MDUzCQlEQTkwNTM6IGZsZXhpYmxlIHN5c3RlbSBsZXZlbCBQTUlDIHdpdGggbXVsdGljb3JlIHN1cHBvcnQKK2RsZyxkYTkwNjMJCURBOTA2Mzogc3lzdGVtIFBNSUMgZm9yIHF1YWQtY29yZSBhcHBsaWNhdGlvbiBwcm9jZXNzb3JzCiBlcHNvbixyeDgwMjUJCUhpZ2gtU3RhYmlsaXR5LiBJMkMtQnVzIElOVEVSRkFDRSBSRUFMIFRJTUUgQ0xPQ0sgTU9EVUxFCiBlcHNvbixyeDg1ODEJCUkyQy1CVVMgSU5URVJGQUNFIFJFQUwgVElNRSBDTE9DSyBNT0RVTEUKIGZzbCxtYWczMTEwCQlNQUczMTEwOiBYdHJpbnNpYyBIaWdoIEFjY3VyYWN5LCAzRCBNYWduZXRvbWV0ZXIKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9uZXQvZGF2aW5jaV9lbWFjLnR4dCBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9uZXQvZGF2aW5jaV9lbWFjLnR4dAppbmRleCAwMzI4MDg4Li4yNGM1Y2RhIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvbmV0L2RhdmluY2lfZW1hYy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL25ldC9kYXZpbmNpX2VtYWMudHh0CkBAIC00LDcgKzQsOCBAQAogZm9yIHRoZSBkYXZpbmNpX2VtYWMgaW50ZXJmYWNlIGNvbnRhaW5zLgogCiBSZXF1aXJlZCBwcm9wZXJ0aWVzOgotLSBjb21wYXRpYmxlOiAidGksZGF2aW5jaS1kbTY0NjctZW1hYyIgb3IgInRpLGFtMzUxNy1lbWFjIgorLSBjb21wYXRpYmxlOiAidGksZGF2aW5jaS1kbTY0NjctZW1hYyIsICJ0aSxhbTM1MTctZW1hYyIgb3IKKyAgInRpLGRtODE2LWVtYWMiCiAtIHJlZzogT2Zmc2V0IGFuZCBsZW5ndGggb2YgdGhlIHJlZ2lzdGVyIHNldCBmb3IgdGhlIGRldmljZQogLSB0aSxkYXZpbmNpLWN0cmwtcmVnLW9mZnNldDogb2Zmc2V0IHRvIGNvbnRyb2wgcmVnaXN0ZXIKIC0gdGksZGF2aW5jaS1jdHJsLW1vZC1yZWctb2Zmc2V0OiBvZmZzZXQgdG8gY29udHJvbCBtb2R1bGUgcmVnaXN0ZXIKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy92ZW5kb3ItcHJlZml4ZXMudHh0IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3ZlbmRvci1wcmVmaXhlcy50eHQKaW5kZXggYjFkZjBhZC4uZDQ0MzI3OSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3ZlbmRvci1wcmVmaXhlcy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3ZlbmRvci1wcmVmaXhlcy50eHQKQEAgLTksNyArOSw2IEBACiBhZGFwdGV2YQlBZGFwdGV2YSwgSW5jLgogYWRpCUFuYWxvZyBEZXZpY2VzLCBJbmMuCiBhZXJvZmxleGdhaXNsZXIJQWVyb2ZsZXggR2Fpc2xlciBBQgotYWsJQXNhaGkgS2FzZWkgQ29ycC4KIGFsbHdpbm5lcglBbGx3aW5uZXIgVGVjaG5vbG9neSBDby4sIEx0ZC4KIGFsdHIJQWx0ZXJhIENvcnAuCiBhbWNjCUFwcGxpZWQgTWljcm8gQ2lyY3VpdHMgQ29ycG9yYXRpb24gKEFQTSwgZm9ybWFsbHkgQU1DQykKQEAgLTIwLDYgKzE5LDcgQEAKIGFwbQlBcHBsaWVkIE1pY3JvIENpcmN1aXRzIENvcnBvcmF0aW9uIChBUE0pCiBhcm0JQVJNIEx0ZC4KIGFybWFkZXVzCUFSTWFkZXVzIFN5c3RlbXMgU0FSTAorYXNhaGkta2FzZWkJQXNhaGkgS2FzZWkgQ29ycC4KIGF0bWVsCUF0bWVsIENvcnBvcmF0aW9uCiBhdW8JQVUgT3B0cm9uaWNzIENvcnBvcmF0aW9uCiBhdmFnbwlBdmFnbyBUZWNobm9sb2dpZXMKQEAgLTEyNyw2ICsxMjcsNyBAQAogcG93ZXJ2cglQb3dlclZSIChkZXByZWNhdGVkLCB1c2UgaW1nKQogcWNhCVF1YWxjb21tIEF0aGVyb3MsIEluYy4KIHFjb20JUXVhbGNvbW0gVGVjaG5vbG9naWVzLCBJbmMKK3FlbXUJUUVNVSwgYSBnZW5lcmljIGFuZCBvcGVuIHNvdXJjZSBtYWNoaW5lIGVtdWxhdG9yIGFuZCB2aXJ0dWFsaXplcgogcW5hcAlRTkFQIFN5c3RlbXMsIEluYy4KIHJhZHhhCVJhZHhhCiByYWlkc29uaWMJUmFpZFNvbmljIFRlY2hub2xvZ3kgR21iSApAQCAtMTY4LDYgKzE2OSw3IEBACiB2MwlWMyBTZW1pY29uZHVjdG9yCiB2YXJpc2NpdGUJVmFyaXNjaXRlIEx0ZC4KIHZpYQlWSUEgVGVjaG5vbG9naWVzLCBJbmMuCit2aXJ0aW8JVmlydHVhbCBJL08gRGV2aWNlIFNwZWNpZmljYXRpb24sIGRldmVsb3BlZCBieSB0aGUgT0FTSVMgY29uc29ydGl1bQogdm9pcGFjCVZvaXBhYyBUZWNobm9sb2dpZXMgcy5yLm8uCiB3aW5ib25kIFdpbmJvbmQgRWxlY3Ryb25pY3MgY29ycC4KIHdsZglXb2xmc29uIE1pY3JvZWxlY3Ryb25pY3MKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24va2VybmVsLXBhcmFtZXRlcnMudHh0IGIvRG9jdW1lbnRhdGlvbi9rZXJuZWwtcGFyYW1ldGVycy50eHQKaW5kZXggNGRmNzNkYS4uMTc2ZDRmZSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9rZXJuZWwtcGFyYW1ldGVycy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9rZXJuZWwtcGFyYW1ldGVycy50eHQKQEAgLTEyNzcsNiArMTI3Nyw3IEBACiAJaTgwNDIubm90aW1lb3V0CVtIV10gSWdub3JlIHRpbWVvdXQgY29uZGl0aW9uIHNpZ25hbGxlZCBieSBjb250cm9sbGVyCiAJaTgwNDIucmVzZXQJW0hXXSBSZXNldCB0aGUgY29udHJvbGxlciBkdXJpbmcgaW5pdCBhbmQgY2xlYW51cAogCWk4MDQyLnVubG9jawlbSFddIFVubG9jayAoaWdub3JlKSB0aGUga2V5bG9jaworCWk4MDQyLmtiZHJlc2V0ICBbSFddIFJlc2V0IGRldmljZSBjb25uZWN0ZWQgdG8gS0JEIHBvcnQKIAogCWk4MTA9CQlbSFcsRFJNXQogCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL25ldHdvcmtpbmcvbmV0bGlua19tbWFwLnR4dCBiL0RvY3VtZW50YXRpb24vbmV0d29ya2luZy9uZXRsaW5rX21tYXAudHh0CmluZGV4IGM2YWY0YmEuLjU0ZjEwNDcgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vbmV0d29ya2luZy9uZXRsaW5rX21tYXAudHh0CisrKyBiL0RvY3VtZW50YXRpb24vbmV0d29ya2luZy9uZXRsaW5rX21tYXAudHh0CkBAIC0xOTksMTYgKzE5OSw5IEBACiBUWCBsaW1pdGF0aW9ucwogLS0tLS0tLS0tLS0tLS0KIAotS2VybmVsIHByb2Nlc3NpbmcgdXN1YWxseSBpbnZvbHZlcyB2YWxpZGF0aW9uIG9mIHRoZSBtZXNzYWdlIHJlY2VpdmVkIGJ5Ci11c2VyLXNwYWNlLCB0aGVuIHByb2Nlc3NpbmcgaXRzIGNvbnRlbnRzLiBUaGUga2VybmVsIG11c3QgYXNzdXJlIHRoYXQKLXVzZXJzcGFjZSBpcyBub3QgYWJsZSB0byBtb2RpZnkgdGhlIG1lc3NhZ2UgY29udGVudHMgYWZ0ZXIgdGhleSBoYXZlIGJlZW4KLXZhbGlkYXRlZC4gSW4gb3JkZXIgdG8gZG8gc28sIHRoZSBtZXNzYWdlIGlzIGNvcGllZCBmcm9tIHRoZSByaW5nIGZyYW1lCi10byBhbiBhbGxvY2F0ZWQgYnVmZmVyIGlmIGVpdGhlciBvZiB0aGVzZSBjb25kaXRpb25zIGlzIGZhbHNlOgotCi0tIG9ubHkgYSBzaW5nbGUgbWFwcGluZyBvZiB0aGUgcmluZyBleGlzdHMKLS0gdGhlIGZpbGUgZGVzY3JpcHRvciBpcyBub3Qgc2hhcmVkIGJldHdlZW4gcHJvY2Vzc2VzCi0KLVRoaXMgbWVhbnMgdGhhdCBmb3IgdGhyZWFkZWQgcHJvZ3JhbXMsIHRoZSBrZXJuZWwgd2lsbCBmYWxsIGJhY2sgdG8gY29weWluZy4KK0FzIG9mIEphbiAyMDE1IHRoZSBtZXNzYWdlIGlzIGFsd2F5cyBjb3BpZWQgZnJvbSB0aGUgcmluZyBmcmFtZSB0byBhbgorYWxsb2NhdGVkIGJ1ZmZlciBkdWUgdG8gdW5yZXNvbHZlZCBzZWN1cml0eSBjb25jZXJucy4KK1NlZSBjb21taXQgNDY4MmEwMzU4NjM5YjI5Y2YgKCJuZXRsaW5rOiBBbHdheXMgY29weSBvbiBtbWFwIFRYLiIpLgogCiBFeGFtcGxlCiAtLS0tLS0tCmRpZmYgLS1naXQgYS9NQUlOVEFJTkVSUyBiL01BSU5UQUlORVJTCmluZGV4IDJmYTM4NTMuLmE1MmVkOWMgMTAwNjQ0Ci0tLSBhL01BSU5UQUlORVJTCisrKyBiL01BSU5UQUlORVJTCkBAIC0yNzAsMTIgKzI3MCwxMiBAQAogRjoJZHJpdmVycy9wbnAvcG5wYWNwaS8KIEY6CWluY2x1ZGUvbGludXgvYWNwaS5oCiBGOglpbmNsdWRlL2FjcGkvCi1GOglEb2N1bWVudGF0aW9uL2FjcGkKK0Y6CURvY3VtZW50YXRpb24vYWNwaS8KIEY6CURvY3VtZW50YXRpb24vQUJJL3Rlc3Rpbmcvc3lzZnMtYnVzLWFjcGkKIEY6CWRyaXZlcnMvcGNpLyphY3BpKgogRjoJZHJpdmVycy9wY2kvKi8qYWNwaSoKIEY6CWRyaXZlcnMvcGNpLyovKi8qYWNwaSoKLUY6CXRvb2xzL3Bvd2VyL2FjcGkKK0Y6CXRvb2xzL3Bvd2VyL2FjcGkvCiAKIEFDUEkgQ09NUE9ORU5UIEFSQ0hJVEVDVFVSRSAoQUNQSUNBKQogTToJUm9iZXJ0IE1vb3JlIDxyb2JlcnQubW9vcmVAaW50ZWwuY29tPgpAQCAtNjk2LDcgKzY5Niw3IEBACiBXOglodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCiBTOglTdXBwb3J0ZWQKIEY6CXNvdW5kL3NvYy9ibGFja2Zpbi8qCi0gCisKIEFOQUxPRyBERVZJQ0VTIElOQyBJSU8gRFJJVkVSUwogTToJTGFycy1QZXRlciBDbGF1c2VuIDxsYXJzQG1ldGFmb28uZGU+CiBNOglNaWNoYWVsIEhlbm5lcmljaCA8TWljaGFlbC5IZW5uZXJpY2hAYW5hbG9nLmNvbT4KQEAgLTcwOCw2ICs3MDgsMTYgQEAKIEY6CWRyaXZlcnMvc3RhZ2luZy9paW8vKi9hZCoKIEY6CXN0YWdpbmcvaWlvL3RyaWdnZXIvaWlvLXRyaWctYmZpbi10aW1lci5jCiAKK0FORFJPSUQgRFJJVkVSUworTToJR3JlZyBLcm9haC1IYXJ0bWFuIDxncmVna2hAbGludXhmb3VuZGF0aW9uLm9yZz4KK006CUFydmUgSGr4bm5lduVnIDxhcnZlQGFuZHJvaWQuY29tPgorTToJUmlsZXkgQW5kcmV3cyA8cmlhbmRyZXdzQGFuZHJvaWQuY29tPgorVDoJZ2l0IGdpdDovL2dpdC5rZXJuZWwub3JnL3B1Yi9zY20vbGludXgva2VybmVsL2dyZWdraC9zdGFnaW5nLmdpdAorTDoJZGV2ZWxAZHJpdmVyZGV2Lm9zdW9zbC5vcmcKK1M6CVN1cHBvcnRlZAorRjoJZHJpdmVycy9hbmRyb2lkLworRjoJZHJpdmVycy9zdGFnaW5nL2FuZHJvaWQvCisKIEFPQSAoQXBwbGUgT25ib2FyZCBBdWRpbykgQUxTQSBEUklWRVIKIE06CUpvaGFubmVzIEJlcmcgPGpvaGFubmVzQHNpcHNvbHV0aW9ucy5uZXQ+CiBMOglsaW51eHBwYy1kZXZAbGlzdHMub3psYWJzLm9yZwpAQCAtNzU0LDEzICs3NjQsNiBAQAogUzoJTWFpbnRhaW5lZAogRjoJZHJpdmVycy9tZWRpYS9pMmMvYXB0aW5hLXBsbC4qCiAKLUFSQVNBTiBDT01QQUNUIEZMQVNIIFBBVEEgQ09OVFJPTExFUgotTToJVmlyZXNoIEt1bWFyIDx2aXJlc2gubGludXhAZ21haWwuY29tPgotTDoJbGludXgtaWRlQHZnZXIua2VybmVsLm9yZwotUzoJTWFpbnRhaW5lZAotRjoJaW5jbHVkZS9saW51eC9wYXRhX2FyYXNhbl9jZl9kYXRhLmgKLUY6CWRyaXZlcnMvYXRhL3BhdGFfYXJhc2FuX2NmLmMKLQogQVJDIEZSQU1FQlVGRkVSIERSSVZFUgogTToJSmF5YSBLdW1hciA8amF5YWxrQGludHdvcmtzLmJpej4KIFM6CU1haW50YWluZWQKQEAgLTIzNDYsNyArMjM0OSw4IEBACiBNOglPbGl2ZXIgSGFydGtvcHAgPHNvY2tldGNhbkBoYXJ0a29wcC5uZXQ+CiBMOglsaW51eC1jYW5Admdlci5rZXJuZWwub3JnCiBXOglodHRwOi8vZ2l0b3Jpb3VzLm9yZy9saW51eC1jYW4KLVQ6CWdpdCBnaXQ6Ly9naXRvcmlvdXMub3JnL2xpbnV4LWNhbi9saW51eC1jYW4tbmV4dC5naXQKK1Q6CWdpdCBnaXQ6Ly9naXQua2VybmVsLm9yZy9wdWIvc2NtL2xpbnV4L2tlcm5lbC9naXQvbWtsL2xpbnV4LWNhbi5naXQKK1Q6CWdpdCBnaXQ6Ly9naXQua2VybmVsLm9yZy9wdWIvc2NtL2xpbnV4L2tlcm5lbC9naXQvbWtsL2xpbnV4LWNhbi1uZXh0LmdpdAogUzoJTWFpbnRhaW5lZAogRjoJRG9jdW1lbnRhdGlvbi9uZXR3b3JraW5nL2Nhbi50eHQKIEY6CW5ldC9jYW4vCkBAIC0yMzYxLDcgKzIzNjUsOCBAQAogTToJTWFyYyBLbGVpbmUtQnVkZGUgPG1rbEBwZW5ndXRyb25peC5kZT4KIEw6CWxpbnV4LWNhbkB2Z2VyLmtlcm5lbC5vcmcKIFc6CWh0dHA6Ly9naXRvcmlvdXMub3JnL2xpbnV4LWNhbgotVDoJZ2l0IGdpdDovL2dpdG9yaW91cy5vcmcvbGludXgtY2FuL2xpbnV4LWNhbi1uZXh0LmdpdAorVDoJZ2l0IGdpdDovL2dpdC5rZXJuZWwub3JnL3B1Yi9zY20vbGludXgva2VybmVsL2dpdC9ta2wvbGludXgtY2FuLmdpdAorVDoJZ2l0IGdpdDovL2dpdC5rZXJuZWwub3JnL3B1Yi9zY20vbGludXgva2VybmVsL2dpdC9ta2wvbGludXgtY2FuLW5leHQuZ2l0CiBTOglNYWludGFpbmVkCiBGOglkcml2ZXJzL25ldC9jYW4vCiBGOglpbmNsdWRlL2xpbnV4L2Nhbi9kZXYuaApAQCAtNDc1NSwxNCArNDc2MCwxNCBAQAogRjoJZHJpdmVycy9uZXQvZXRoZXJuZXQvaWJtL2libXZldGguKgogCiBJQk0gUG93ZXIgVmlydHVhbCBTQ1NJIERldmljZSBEcml2ZXJzCi1NOglOYXRoYW4gRm9udGVub3QgPG5mb250QGxpbnV4LnZuZXQuaWJtLmNvbT4KK006CVR5cmVsIERhdHd5bGVyIDx0eXJlbGRAbGludXgudm5ldC5pYm0uY29tPgogTDoJbGludXgtc2NzaUB2Z2VyLmtlcm5lbC5vcmcKIFM6CVN1cHBvcnRlZAogRjoJZHJpdmVycy9zY3NpL2libXZzY3NpL2libXZzY3NpKgogRjoJZHJpdmVycy9zY3NpL2libXZzY3NpL3Zpb3NycC5oCiAKIElCTSBQb3dlciBWaXJ0dWFsIEZDIERldmljZSBEcml2ZXJzCi1NOglCcmlhbiBLaW5nIDxicmtpbmdAbGludXgudm5ldC5pYm0uY29tPgorTToJVHlyZWwgRGF0d3lsZXIgPHR5cmVsZEBsaW51eC52bmV0LmlibS5jb20+CiBMOglsaW51eC1zY3NpQHZnZXIua2VybmVsLm9yZwogUzoJU3VwcG9ydGVkCiBGOglkcml2ZXJzL3Njc2kvaWJtdnNjc2kvaWJtdmZjKgpAQCAtNDkzMCw3ICs0OTM1LDYgQEAKIAogSU5QVVQgKEtFWUJPQVJELCBNT1VTRSwgSk9ZU1RJQ0ssIFRPVUNIU0NSRUVOKSBEUklWRVJTCiBNOglEbWl0cnkgVG9yb2tob3YgPGRtaXRyeS50b3Jva2hvdkBnbWFpbC5jb20+Ci1NOglEbWl0cnkgVG9yb2tob3YgPGR0b3JAbWFpbC5ydT4KIEw6CWxpbnV4LWlucHV0QHZnZXIua2VybmVsLm9yZwogUToJaHR0cDovL3BhdGNod29yay5rZXJuZWwub3JnL3Byb2plY3QvbGludXgtaW5wdXQvbGlzdC8KIFQ6CWdpdCBnaXQ6Ly9naXQua2VybmVsLm9yZy9wdWIvc2NtL2xpbnV4L2tlcm5lbC9naXQvZHRvci9pbnB1dC5naXQKQEAgLTQ5NDksMTAgKzQ5NTMsMTkgQEAKIEY6CWRyaXZlcnMvaW5wdXQvaW5wdXQtbXQuYwogSzoJXGIoQUJTfFNZTilfTVRfCiAKK0lOVEVMIEFTb0MgQkRXL0hTVyBEUklWRVJTCitNOglKaWUgWWFuZyA8eWFuZy5qaWVAbGludXguaW50ZWwuY29tPgorTDoJYWxzYS1kZXZlbEBhbHNhLXByb2plY3Qub3JnCitTOglTdXBwb3J0ZWQKK0Y6CXNvdW5kL3NvYy9pbnRlbC9zc3QtaGFzd2VsbCoKK0Y6CXNvdW5kL3NvYy9pbnRlbC9zc3QtZHNwKgorRjoJc291bmQvc29jL2ludGVsL3NzdC1maXJtd2FyZS5jCitGOglzb3VuZC9zb2MvaW50ZWwvYnJvYWR3ZWxsLmMKK0Y6CXNvdW5kL3NvYy9pbnRlbC9oYXN3ZWxsLmMKKwogSU5URUwgQzYwMCBTRVJJRVMgU0FTIENPTlRST0xMRVIgRFJJVkVSCiBNOglJbnRlbCBTQ1UgTGludXggc3VwcG9ydCA8aW50ZWwtbGludXgtc2N1QGludGVsLmNvbT4KIE06CUFydHVyIFBhc3praWV3aWN6IDxhcnR1ci5wYXN6a2lld2ljekBpbnRlbC5jb20+Ci1NOglEYXZlIEppYW5nIDxkYXZlLmppYW5nQGludGVsLmNvbT4KIEw6CWxpbnV4LXNjc2lAdmdlci5rZXJuZWwub3JnCiBUOglnaXQgZ2l0Oi8vZ2l0LmNvZGUuc2YubmV0L3AvaW50ZWwtc2FzL2lzY2kKIFM6CVN1cHBvcnRlZApAQCAtNTcwMyw2ICs1NzE2LDQ5IEBACiBGOglpbmNsdWRlL2xpbnV4L2xndWVzdCouaAogRjoJdG9vbHMvbGd1ZXN0LwogCitMSUJBVEEgU1VCU1lTVEVNIChTZXJpYWwgYW5kIFBhcmFsbGVsIEFUQSBkcml2ZXJzKQorTToJVGVqdW4gSGVvIDx0akBrZXJuZWwub3JnPgorTDoJbGludXgtaWRlQHZnZXIua2VybmVsLm9yZworVDoJZ2l0IGdpdDovL2dpdC5rZXJuZWwub3JnL3B1Yi9zY20vbGludXgva2VybmVsL2dpdC90ai9saWJhdGEuZ2l0CitTOglNYWludGFpbmVkCitGOglkcml2ZXJzL2F0YS8KK0Y6CWluY2x1ZGUvbGludXgvYXRhLmgKK0Y6CWluY2x1ZGUvbGludXgvbGliYXRhLmgKKworTElCQVRBIFBBVEEgQVJBU0FOIENPTVBBQ1QgRkxBU0ggQ09OVFJPTExFUgorTToJVmlyZXNoIEt1bWFyIDx2aXJlc2gubGludXhAZ21haWwuY29tPgorTDoJbGludXgtaWRlQHZnZXIua2VybmVsLm9yZworVDoJZ2l0IGdpdDovL2dpdC5rZXJuZWwub3JnL3B1Yi9zY20vbGludXgva2VybmVsL2dpdC90ai9saWJhdGEuZ2l0CitTOglNYWludGFpbmVkCitGOglpbmNsdWRlL2xpbnV4L3BhdGFfYXJhc2FuX2NmX2RhdGEuaAorRjoJZHJpdmVycy9hdGEvcGF0YV9hcmFzYW5fY2YuYworCitMSUJBVEEgUEFUQSBEUklWRVJTCitNOglCYXJ0bG9taWVqIFpvbG5pZXJraWV3aWN6IDxiLnpvbG5pZXJraWVAc2Ftc3VuZy5jb20+CitNOglUZWp1biBIZW8gPHRqQGtlcm5lbC5vcmc+CitMOglsaW51eC1pZGVAdmdlci5rZXJuZWwub3JnCitUOglnaXQgZ2l0Oi8vZ2l0Lmtlcm5lbC5vcmcvcHViL3NjbS9saW51eC9rZXJuZWwvZ2l0L3RqL2xpYmF0YS5naXQKK1M6CU1haW50YWluZWQKK0Y6CWRyaXZlcnMvYXRhL3BhdGFfKi5jCitGOglkcml2ZXJzL2F0YS9hdGFfZ2VuZXJpYy5jCisKK0xJQkFUQSBTQVRBIEFIQ0kgUExBVEZPUk0gZGV2aWNlcyBzdXBwb3J0CitNOglIYW5zIGRlIEdvZWRlIDxoZGVnb2VkZUByZWRoYXQuY29tPgorTToJVGVqdW4gSGVvIDx0akBrZXJuZWwub3JnPgorTDoJbGludXgtaWRlQHZnZXIua2VybmVsLm9yZworVDoJZ2l0IGdpdDovL2dpdC5rZXJuZWwub3JnL3B1Yi9zY20vbGludXgva2VybmVsL2dpdC90ai9saWJhdGEuZ2l0CitTOglNYWludGFpbmVkCitGOglkcml2ZXJzL2F0YS9haGNpX3BsYXRmb3JtLmMKK0Y6CWRyaXZlcnMvYXRhL2xpYmFoY2lfcGxhdGZvcm0uYworRjoJaW5jbHVkZS9saW51eC9haGNpX3BsYXRmb3JtLmgKKworTElCQVRBIFNBVEEgUFJPTUlTRSBUWDIvVFg0IENPTlRST0xMRVIgRFJJVkVSCitNOglNaWthZWwgUGV0dGVyc3NvbiA8bWlrcGVsaW51eEBnbWFpbC5jb20+CitMOglsaW51eC1pZGVAdmdlci5rZXJuZWwub3JnCitUOglnaXQgZ2l0Oi8vZ2l0Lmtlcm5lbC5vcmcvcHViL3NjbS9saW51eC9rZXJuZWwvZ2l0L3RqL2xpYmF0YS5naXQKK1M6CU1haW50YWluZWQKK0Y6CWRyaXZlcnMvYXRhL3NhdGFfcHJvbWlzZS4qCisKIExJQkxPQ0tERVAKIE06CVNhc2hhIExldmluIDxzYXNoYS5sZXZpbkBvcmFjbGUuY29tPgogUzoJTWFpbnRhaW5lZApAQCAtNjk4NywxNCArNzA0MywxMiBAQAogTToJR3JhbnQgTGlrZWx5IDxncmFudC5saWtlbHlAbGluYXJvLm9yZz4KIE06CVJvYiBIZXJyaW5nIDxyb2JoK2R0QGtlcm5lbC5vcmc+CiBMOglkZXZpY2V0cmVlQHZnZXIua2VybmVsLm9yZwotVzoJaHR0cDovL2ZkdC5zZWNyZXRsYWIuY2EKLVQ6CWdpdCBnaXQ6Ly9naXQuc2VjcmV0bGFiLmNhL2dpdC9saW51eC0yLjYuZ2l0CitXOglodHRwOi8vd3d3LmRldmljZXRyZWUub3JnLworVDoJZ2l0IGdpdDovL2dpdC5rZXJuZWwub3JnL3B1Yi9zY20vbGludXgva2VybmVsL2dpdC9nbGlrZWx5L2xpbnV4LmdpdAogUzoJTWFpbnRhaW5lZAogRjoJZHJpdmVycy9vZi8KIEY6CWluY2x1ZGUvbGludXgvb2YqLmgKIEY6CXNjcmlwdHMvZHRjLwotSzoJb2ZfZ2V0X3Byb3BlcnR5Ci1LOglvZl9tYXRjaF90YWJsZQogCiBPUEVOIEZJUk1XQVJFIEFORCBGTEFUVEVORUQgREVWSUNFIFRSRUUgQklORElOR1MKIE06CVJvYiBIZXJyaW5nIDxyb2JoK2R0QGtlcm5lbC5vcmc+CkBAIC03MjM5LDcgKzcyOTMsNyBAQAogRjoJZHJpdmVycy9wY2kvaG9zdC8qbGF5ZXJzY2FwZSoKIAogUENJIERSSVZFUiBGT1IgSU1YNgotTToJUmljaGFyZCBaaHUgPHI2NTAzN0BmcmVlc2NhbGUuY29tPgorTToJUmljaGFyZCBaaHUgPFJpY2hhcmQuWmh1QGZyZWVzY2FsZS5jb20+CiBNOglMdWNhcyBTdGFjaCA8bC5zdGFjaEBwZW5ndXRyb25peC5kZT4KIEw6CWxpbnV4LXBjaUB2Z2VyLmtlcm5lbC5vcmcKIEw6CWxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZyAobW9kZXJhdGVkIGZvciBub24tc3Vic2NyaWJlcnMpCkBAIC03NDA5LDYgKzc0NjMsNyBAQAogUElOIENPTlRST0wgU1VCU1lTVEVNCiBNOglMaW51cyBXYWxsZWlqIDxsaW51cy53YWxsZWlqQGxpbmFyby5vcmc+CiBMOglsaW51eC1ncGlvQHZnZXIua2VybmVsLm9yZworVDoJZ2l0IGdpdDovL2dpdC5rZXJuZWwub3JnL3B1Yi9zY20vbGludXgva2VybmVsL2dpdC9saW51c3cvbGludXgtcGluY3RybC5naXQKIFM6CU1haW50YWluZWQKIEY6CWRyaXZlcnMvcGluY3RybC8KIEY6CWluY2x1ZGUvbGludXgvcGluY3RybC8KQEAgLTc1NzYsMTIgKzc2MzEsNiBAQAogUzoJT2Jzb2xldGUKIEY6CWRyaXZlcnMvbmV0L3dpcmVsZXNzL3ByaXNtNTQvCiAKLVBST01JU0UgU0FUQSBUWDIvVFg0IENPTlRST0xMRVIgTElCQVRBIERSSVZFUgotTToJTWlrYWVsIFBldHRlcnNzb24gPG1pa3BlbGludXhAZ21haWwuY29tPgotTDoJbGludXgtaWRlQHZnZXIua2VybmVsLm9yZwotUzoJTWFpbnRhaW5lZAotRjoJZHJpdmVycy9hdGEvc2F0YV9wcm9taXNlLioKLQogUFMzIE5FVFdPUksgU1VQUE9SVAogTToJR2VvZmYgTGV2YW5kIDxnZW9mZkBpbmZyYWRlYWQub3JnPgogTDoJbmV0ZGV2QHZnZXIua2VybmVsLm9yZwpAQCAtODU1NSwyNSArODYwNCw2IEBACiBGOglkcml2ZXJzL21pc2MvcGhhbnRvbS5jCiBGOglpbmNsdWRlL3VhcGkvbGludXgvcGhhbnRvbS5oCiAKLVNFUklBTCBBVEEgKFNBVEEpIFNVQlNZU1RFTQotTToJVGVqdW4gSGVvIDx0akBrZXJuZWwub3JnPgotTDoJbGludXgtaWRlQHZnZXIua2VybmVsLm9yZwotVDoJZ2l0IGdpdDovL2dpdC5rZXJuZWwub3JnL3B1Yi9zY20vbGludXgva2VybmVsL2dpdC90ai9saWJhdGEuZ2l0Ci1TOglTdXBwb3J0ZWQKLUY6CWRyaXZlcnMvYXRhLwotRjoJaW5jbHVkZS9saW51eC9hdGEuaAotRjoJaW5jbHVkZS9saW51eC9saWJhdGEuaAotCi1TRVJJQUwgQVRBIEFIQ0kgUExBVEZPUk0gZGV2aWNlcyBzdXBwb3J0Ci1NOglIYW5zIGRlIEdvZWRlIDxoZGVnb2VkZUByZWRoYXQuY29tPgotTToJVGVqdW4gSGVvIDx0akBrZXJuZWwub3JnPgotTDoJbGludXgtaWRlQHZnZXIua2VybmVsLm9yZwotVDoJZ2l0IGdpdDovL2dpdC5rZXJuZWwub3JnL3B1Yi9zY20vbGludXgva2VybmVsL2dpdC90ai9saWJhdGEuZ2l0Ci1TOglTdXBwb3J0ZWQKLUY6CWRyaXZlcnMvYXRhL2FoY2lfcGxhdGZvcm0uYwotRjoJZHJpdmVycy9hdGEvbGliYWhjaV9wbGF0Zm9ybS5jCi1GOglpbmNsdWRlL2xpbnV4L2FoY2lfcGxhdGZvcm0uaAotCiBTRVJWRVIgRU5HSU5FUyAxMEdicHMgaVNDU0kgLSBCbGFkZUVuZ2luZSAyIERSSVZFUgogTToJSmF5YW1vaGFuIEthbGxpY2thbCA8amF5YW1vaGFuLmthbGxpY2thbEBlbXVsZXguY29tPgogTDoJbGludXgtc2NzaUB2Z2VyLmtlcm5lbC5vcmcKQEAgLTkyMjEsNyArOTI1MSw2IEBACiAKIFNVUEVSSAogTDoJbGludXgtc2hAdmdlci5rZXJuZWwub3JnCi1XOglodHRwOi8vd3d3LmxpbnV4LXNoLm9yZwogUToJaHR0cDovL3BhdGNod29yay5rZXJuZWwub3JnL3Byb2plY3QvbGludXgtc2gvbGlzdC8KIFM6CU9ycGhhbgogRjoJRG9jdW1lbnRhdGlvbi9zaC8KQEAgLTEwMTU2LDYgKzEwMTg1LDcgQEAKIE06CSJIYW5zIEouIEtvY2giIDxoamtAaGFuc2prb2NoLmRlPgogTToJR3JlZyBLcm9haC1IYXJ0bWFuIDxncmVna2hAbGludXhmb3VuZGF0aW9uLm9yZz4KIFM6CU1haW50YWluZWQKK1Q6CWdpdCBnaXQ6Ly9naXQua2VybmVsLm9yZy9wdWIvc2NtL2xpbnV4L2tlcm5lbC9naXQvZ3JlZ2toL2NoYXItbWlzYy5naXQKIEY6CURvY3VtZW50YXRpb24vRG9jQm9vay91aW8taG93dG8udG1wbAogRjoJZHJpdmVycy91aW8vCiBGOglpbmNsdWRlL2xpbnV4L3VpbyouaApkaWZmIC0tZ2l0IGEvTWFrZWZpbGUgYi9NYWtlZmlsZQppbmRleCBmYjkzMzUwLi5iMTUwMzZiIDEwMDY0NAotLS0gYS9NYWtlZmlsZQorKysgYi9NYWtlZmlsZQpAQCAtMSw3ICsxLDcgQEAKIFZFUlNJT04gPSAzCiBQQVRDSExFVkVMID0gMTkKIFNVQkxFVkVMID0gMAotRVhUUkFWRVJTSU9OID0gLXJjNQorRVhUUkFWRVJTSU9OID0KIE5BTUUgPSBEaXNlYXNlZCBOZXd0CiAKICMgKkRPQ1VNRU5UQVRJT04qCmRpZmYgLS1naXQgYS9hcmNoL2FscGhhL2tlcm5lbC9wY2kuYyBiL2FyY2gvYWxwaGEva2VybmVsL3BjaS5jCmluZGV4IDA3NmMzNWMuLjk4YTE1MjUgMTAwNjQ0Ci0tLSBhL2FyY2gvYWxwaGEva2VybmVsL3BjaS5jCisrKyBiL2FyY2gvYWxwaGEva2VybmVsL3BjaS5jCkBAIC0yODUsOCArMjg1LDEyIEBACiAJCQlpZiAoci0+cGFyZW50IHx8ICFyLT5zdGFydCB8fCAhci0+ZmxhZ3MpCiAJCQkJY29udGludWU7CiAJCQlpZiAocGNpX2hhc19mbGFnKFBDSV9QUk9CRV9PTkxZKSB8fAotCQkJICAgIChyLT5mbGFncyAmIElPUkVTT1VSQ0VfUENJX0ZJWEVEKSkKLQkJCQlwY2lfY2xhaW1fcmVzb3VyY2UoZGV2LCBpKTsKKwkJCSAgICAoci0+ZmxhZ3MgJiBJT1JFU09VUkNFX1BDSV9GSVhFRCkpIHsKKwkJCQlpZiAocGNpX2NsYWltX3Jlc291cmNlKGRldiwgaSkgPT0gMCkKKwkJCQkJY29udGludWU7CisKKwkJCQlwY2lfY2xhaW1fYnJpZGdlX3Jlc291cmNlKGRldiwgaSk7CisJCQl9CiAJCX0KIAl9CiAKZGlmZiAtLWdpdCBhL2FyY2gvYWxwaGEvbW0vZmF1bHQuYyBiL2FyY2gvYWxwaGEvbW0vZmF1bHQuYwppbmRleCA5ODgzOGEwLi45ZDBhYzA5IDEwMDY0NAotLS0gYS9hcmNoL2FscGhhL21tL2ZhdWx0LmMKKysrIGIvYXJjaC9hbHBoYS9tbS9mYXVsdC5jCkBAIC0xNTYsNiArMTU2LDggQEAKIAlpZiAodW5saWtlbHkoZmF1bHQgJiBWTV9GQVVMVF9FUlJPUikpIHsKIAkJaWYgKGZhdWx0ICYgVk1fRkFVTFRfT09NKQogCQkJZ290byBvdXRfb2ZfbWVtb3J5OworCQllbHNlIGlmIChmYXVsdCAmIFZNX0ZBVUxUX1NJR1NFR1YpCisJCQlnb3RvIGJhZF9hcmVhOwogCQllbHNlIGlmIChmYXVsdCAmIFZNX0ZBVUxUX1NJR0JVUykKIAkJCWdvdG8gZG9fc2lnYnVzOwogCQlCVUcoKTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJjL21tL2ZhdWx0LmMgYi9hcmNoL2FyYy9tbS9mYXVsdC5jCmluZGV4IDZmN2UzYTYuLjU2M2NiMjcgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJjL21tL2ZhdWx0LmMKKysrIGIvYXJjaC9hcmMvbW0vZmF1bHQuYwpAQCAtMTYxLDYgKzE2MSw4IEBACiAKIAlpZiAoZmF1bHQgJiBWTV9GQVVMVF9PT00pCiAJCWdvdG8gb3V0X29mX21lbW9yeTsKKwllbHNlIGlmIChmYXVsdCAmIFZNX0ZBVUxUX1NJR1NFR1YpCisJCWdvdG8gYmFkX2FyZWE7CiAJZWxzZSBpZiAoZmF1bHQgJiBWTV9GQVVMVF9TSUdCVVMpCiAJCWdvdG8gZG9fc2lnYnVzOwogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9ib290L2NvbXByZXNzZWQvaGVhZC5TIGIvYXJjaC9hcm0vYm9vdC9jb21wcmVzc2VkL2hlYWQuUwppbmRleCA2OGJlOTAxLi4xMzJjNzBlIDEwMDY0NAotLS0gYS9hcmNoL2FybS9ib290L2NvbXByZXNzZWQvaGVhZC5TCisrKyBiL2FyY2gvYXJtL2Jvb3QvY29tcHJlc3NlZC9oZWFkLlMKQEAgLTI2MywxNiArMjYzLDM3IEBACiAJCSAqIE9LLi4uIExldCdzIGRvIHNvbWUgZnVua3kgYnVzaW5lc3MgaGVyZS4KIAkJICogSWYgd2UgZG8gaGF2ZSBhIERUQiBhcHBlbmRlZCB0byB6SW1hZ2UsIGFuZCB3ZSBkbyBoYXZlCiAJCSAqIGFuIEFUQUcgbGlzdCBhcm91bmQsIHdlIHdhbnQgdGhlIGxhdGVyIHRvIGJlIHRyYW5zbGF0ZWQKLQkJICogYW5kIGZvbGRlZCBpbnRvIHRoZSBmb3JtZXIgaGVyZS4gIFRvIGJlIG9uIHRoZSBzYWZlIHNpZGUsCi0JCSAqIGxldCdzIHRlbXBvcmFyaWx5IG1vdmUgIHRoZSBzdGFjayBhd2F5IGludG8gdGhlIG1hbGxvYwotCQkgKiBhcmVhLiAgTm8gR09UIGZpeHVwIGhhcyBvY2N1cnJlZCB5ZXQsIGJ1dCBub25lIG9mIHRoZQotCQkgKiBjb2RlIHdlJ3JlIGFib3V0IHRvIGNhbGwgdXNlcyBhbnkgZ2xvYmFsIHZhcmlhYmxlLgorCQkgKiBhbmQgZm9sZGVkIGludG8gdGhlIGZvcm1lciBoZXJlLiBObyBHT1QgZml4dXAgaGFzIG9jY3VycmVkCisJCSAqIHlldCwgYnV0IG5vbmUgb2YgdGhlIGNvZGUgd2UncmUgYWJvdXQgdG8gY2FsbCB1c2VzIGFueQorCQkgKiBnbG9iYWwgdmFyaWFibGUuCiAJCSovCi0JCWFkZAlzcCwgc3AsICMweDEwMDAwCisKKwkJLyogR2V0IHRoZSBpbml0aWFsIERUQiBzaXplICovCisJCWxkcglyNSwgW3I2LCAjNF0KKyNpZm5kZWYgX19BUk1FQl9fCisJCS8qIGNvbnZlcnQgdG8gbGl0dGxlIGVuZGlhbiAqLworCQllb3IJcjEsIHI1LCByNSwgcm9yICMxNgorCQliaWMJcjEsIHIxLCAjMHgwMGZmMDAwMAorCQltb3YJcjUsIHI1LCByb3IgIzgKKwkJZW9yCXI1LCByNSwgcjEsIGxzciAjOAorI2VuZGlmCisJCS8qIDUwJSBEVEIgZ3Jvd3RoIHNob3VsZCBiZSBnb29kIGVub3VnaCAqLworCQlhZGQJcjUsIHI1LCByNSwgbHNyICMxCisJCS8qIHByZXNlcnZlIDY0LWJpdCBhbGlnbm1lbnQgKi8KKwkJYWRkCXI1LCByNSwgIzcKKwkJYmljCXI1LCByNSwgIzcKKwkJLyogY2xhbXAgdG8gMzJLQiBtaW4gYW5kIDFNQiBtYXggKi8KKwkJY21wCXI1LCAjKDEgPDwgMTUpCisJCW1vdmxvCXI1LCAjKDEgPDwgMTUpCisJCWNtcAlyNSwgIygxIDw8IDIwKQorCQltb3ZoaQlyNSwgIygxIDw8IDIwKQorCQkvKiB0ZW1wb3JhcmlseSByZWxvY2F0ZSB0aGUgc3RhY2sgcGFzdCB0aGUgRFRCIHdvcmsgc3BhY2UgKi8KKwkJYWRkCXNwLCBzcCwgcjUKKwogCQlzdG1mZAlzcCEsIHtyMC1yMywgaXAsIGxyfQogCQltb3YJcjAsIHI4CiAJCW1vdglyMSwgcjYKLQkJc3ViCXIyLCBzcCwgcjYKKwkJbW92CXIyLCByNQogCQlibAlhdGFnc190b19mZHQKIAogCQkvKgpAQCAtMjg1LDExICszMDYsMTEgQEAKIAkJYmljCXIwLCByMCwgIzEKIAkJYWRkCXIwLCByMCwgIzB4MTAwCiAJCW1vdglyMSwgcjYKLQkJc3ViCXIyLCBzcCwgcjYKKwkJbW92CXIyLCByNQogCQlibGVxCWF0YWdzX3RvX2ZkdAogCiAJCWxkbWZkCXNwISwge3IwLXIzLCBpcCwgbHJ9Ci0JCXN1YglzcCwgc3AsICMweDEwMDAwCisJCXN1YglzcCwgc3AsIHI1CiAjZW5kaWYKIAogCQltb3YJcjgsIHI2CQkJQCB1c2UgdGhlIGFwcGVuZGVkIGRldmljZSB0cmVlCkBAIC0zMDYsNyArMzI3LDcgQEAKIAkJc3VicwlyMSwgcjUsIHIxCiAJCWFkZGhpCXI5LCByOSwgcjEKIAotCQkvKiBHZXQgdGhlIGR0YidzIHNpemUgKi8KKwkJLyogR2V0IHRoZSBjdXJyZW50IERUQiBzaXplICovCiAJCWxkcglyNSwgW3I2LCAjNF0KICNpZm5kZWYgX19BUk1FQl9fCiAJCS8qIGNvbnZlcnQgcjUgKGR0YiBzaXplKSB0byBsaXR0bGUgZW5kaWFuICovCmRpZmYgLS1naXQgYS9hcmNoL2FybS9ib290L2R0cy9kcmE3LmR0c2kgYi9hcmNoL2FybS9ib290L2R0cy9kcmE3LmR0c2kKaW5kZXggMjI3NzFiYy4uNjNmOGIwMCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vYm9vdC9kdHMvZHJhNy5kdHNpCisrKyBiL2FyY2gvYXJtL2Jvb3QvZHRzL2RyYTcuZHRzaQpAQCAtMTI1Nyw2ICsxMjU3LDggQEAKIAkJCQl0eC1maWZvLXJlc2l6ZTsKIAkJCQltYXhpbXVtLXNwZWVkID0gInN1cGVyLXNwZWVkIjsKIAkJCQlkcl9tb2RlID0gIm90ZyI7CisJCQkJc25wcyxkaXNfdTNfc3VzcGh5X3F1aXJrOworCQkJCXNucHMsZGlzX3UyX3N1c3BoeV9xdWlyazsKIAkJCX07CiAJCX07CiAKQEAgLTEyNzgsNiArMTI4MCw4IEBACiAJCQkJdHgtZmlmby1yZXNpemU7CiAJCQkJbWF4aW11bS1zcGVlZCA9ICJoaWdoLXNwZWVkIjsKIAkJCQlkcl9tb2RlID0gIm90ZyI7CisJCQkJc25wcyxkaXNfdTNfc3VzcGh5X3F1aXJrOworCQkJCXNucHMsZGlzX3UyX3N1c3BoeV9xdWlyazsKIAkJCX07CiAJCX07CiAKQEAgLTEyOTksNiArMTMwMyw4IEBACiAJCQkJdHgtZmlmby1yZXNpemU7CiAJCQkJbWF4aW11bS1zcGVlZCA9ICJoaWdoLXNwZWVkIjsKIAkJCQlkcl9tb2RlID0gIm90ZyI7CisJCQkJc25wcyxkaXNfdTNfc3VzcGh5X3F1aXJrOworCQkJCXNucHMsZGlzX3UyX3N1c3BoeV9xdWlyazsKIAkJCX07CiAJCX07CiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2Jvb3QvZHRzL2V4eW5vczQuZHRzaSBiL2FyY2gvYXJtL2Jvb3QvZHRzL2V4eW5vczQuZHRzaQppbmRleCBiODE2OGYxLi4yNGZmMjcwIDEwMDY0NAotLS0gYS9hcmNoL2FybS9ib290L2R0cy9leHlub3M0LmR0c2kKKysrIGIvYXJjaC9hcm0vYm9vdC9kdHMvZXh5bm9zNC5kdHNpCkBAIC0zNjgsNyArMzY4LDcgQEAKIAl9OwogCiAJaTJzMTogaTJzQDEzOTYwMDAwIHsKLQkJY29tcGF0aWJsZSA9ICJzYW1zdW5nLHM1cHYyMTAtaTJzIjsKKwkJY29tcGF0aWJsZSA9ICJzYW1zdW5nLHMzYzY0MTAtaTJzIjsKIAkJcmVnID0gPDB4MTM5NjAwMDAgMHgxMDA+OwogCQljbG9ja3MgPSA8JmNsb2NrIENMS19JMlMxPjsKIAkJY2xvY2stbmFtZXMgPSAiaWlzIjsKQEAgLTM3OCw3ICszNzgsNyBAQAogCX07CiAKIAlpMnMyOiBpMnNAMTM5NzAwMDAgewotCQljb21wYXRpYmxlID0gInNhbXN1bmcsczVwdjIxMC1pMnMiOworCQljb21wYXRpYmxlID0gInNhbXN1bmcsczNjNjQxMC1pMnMiOwogCQlyZWcgPSA8MHgxMzk3MDAwMCAweDEwMD47CiAJCWNsb2NrcyA9IDwmY2xvY2sgQ0xLX0kyUzI+OwogCQljbG9jay1uYW1lcyA9ICJpaXMiOwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vYm9vdC9kdHMvaW14MjUuZHRzaSBiL2FyY2gvYXJtL2Jvb3QvZHRzL2lteDI1LmR0c2kKaW5kZXggZDIzODY3Ni4uZTRkM2FlYyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vYm9vdC9kdHMvaW14MjUuZHRzaQorKysgYi9hcmNoL2FybS9ib290L2R0cy9pbXgyNS5kdHNpCkBAIC0zNjksNyArMzY5LDcgQEAKIAkJCQljb21wYXRpYmxlID0gImZzbCxpbXgyNS1wd20iLCAiZnNsLGlteDI3LXB3bSI7CiAJCQkJI3B3bS1jZWxscyA9IDwyPjsKIAkJCQlyZWcgPSA8MHg1M2ZhMDAwMCAweDQwMDA+OwotCQkJCWNsb2NrcyA9IDwmY2xrcyAxMDY+LCA8JmNsa3MgMzY+OworCQkJCWNsb2NrcyA9IDwmY2xrcyAxMDY+LCA8JmNsa3MgNTI+OwogCQkJCWNsb2NrLW5hbWVzID0gImlwZyIsICJwZXIiOwogCQkJCWludGVycnVwdHMgPSA8MzY+OwogCQkJfTsKQEAgLTM4OCw3ICszODgsNyBAQAogCQkJCWNvbXBhdGlibGUgPSAiZnNsLGlteDI1LXB3bSIsICJmc2wsaW14MjctcHdtIjsKIAkJCQkjcHdtLWNlbGxzID0gPDI+OwogCQkJCXJlZyA9IDwweDUzZmE4MDAwIDB4NDAwMD47Ci0JCQkJY2xvY2tzID0gPCZjbGtzIDEwNz4sIDwmY2xrcyAzNj47CisJCQkJY2xvY2tzID0gPCZjbGtzIDEwNz4sIDwmY2xrcyA1Mj47CiAJCQkJY2xvY2stbmFtZXMgPSAiaXBnIiwgInBlciI7CiAJCQkJaW50ZXJydXB0cyA9IDw0MT47CiAJCQl9OwpAQCAtNDI5LDcgKzQyOSw3IEBACiAJCQlwd200OiBwd21ANTNmYzgwMDAgewogCQkJCWNvbXBhdGlibGUgPSAiZnNsLGlteDI1LXB3bSIsICJmc2wsaW14MjctcHdtIjsKIAkJCQlyZWcgPSA8MHg1M2ZjODAwMCAweDQwMDA+OwotCQkJCWNsb2NrcyA9IDwmY2xrcyAxMDg+LCA8JmNsa3MgMzY+OworCQkJCWNsb2NrcyA9IDwmY2xrcyAxMDg+LCA8JmNsa3MgNTI+OwogCQkJCWNsb2NrLW5hbWVzID0gImlwZyIsICJwZXIiOwogCQkJCWludGVycnVwdHMgPSA8NDI+OwogCQkJfTsKQEAgLTQ3Niw3ICs0NzYsNyBAQAogCQkJCWNvbXBhdGlibGUgPSAiZnNsLGlteDI1LXB3bSIsICJmc2wsaW14MjctcHdtIjsKIAkJCQkjcHdtLWNlbGxzID0gPDI+OwogCQkJCXJlZyA9IDwweDUzZmUwMDAwIDB4NDAwMD47Ci0JCQkJY2xvY2tzID0gPCZjbGtzIDEwNT4sIDwmY2xrcyAzNj47CisJCQkJY2xvY2tzID0gPCZjbGtzIDEwNT4sIDwmY2xrcyA1Mj47CiAJCQkJY2xvY2stbmFtZXMgPSAiaXBnIiwgInBlciI7CiAJCQkJaW50ZXJydXB0cyA9IDwyNj47CiAJCQl9OwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vYm9vdC9kdHMvaW14NnN4LXNkYi5kdHMgYi9hcmNoL2FybS9ib290L2R0cy9pbXg2c3gtc2RiLmR0cwppbmRleCA4YzFmZWJkLi5jMTA4YmI0IDEwMDY0NAotLS0gYS9hcmNoL2FybS9ib290L2R0cy9pbXg2c3gtc2RiLmR0cworKysgYi9hcmNoL2FybS9ib290L2R0cy9pbXg2c3gtc2RiLmR0cwpAQCAtMTY2LDEyICsxNjYsMTIgQEAKIAkJI2FkZHJlc3MtY2VsbHMgPSA8MT47CiAJCSNzaXplLWNlbGxzID0gPDA+OwogCi0JCWV0aHBoeTE6IGV0aGVybmV0LXBoeUAwIHsKLQkJCXJlZyA9IDwwPjsKKwkJZXRocGh5MTogZXRoZXJuZXQtcGh5QDEgeworCQkJcmVnID0gPDE+OwogCQl9OwogCi0JCWV0aHBoeTI6IGV0aGVybmV0LXBoeUAxIHsKLQkJCXJlZyA9IDwxPjsKKwkJZXRocGh5MjogZXRoZXJuZXQtcGh5QDIgeworCQkJcmVnID0gPDI+OwogCQl9OwogCX07CiB9OwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vYm9vdC9kdHMvc3VuNGktYTEwLmR0c2kgYi9hcmNoL2FybS9ib290L2R0cy9zdW40aS1hMTAuZHRzaQppbmRleCA3YjQwOTlmLi5kNWM0NjY5IDEwMDY0NAotLS0gYS9hcmNoL2FybS9ib290L2R0cy9zdW40aS1hMTAuZHRzaQorKysgYi9hcmNoL2FybS9ib290L2R0cy9zdW40aS1hMTAuZHRzaQpAQCAtMTcsMTQgKzE3LDYgQEAKIAogCWFsaWFzZXMgewogCQlldGhlcm5ldDAgPSAmZW1hYzsKLQkJc2VyaWFsMCA9ICZ1YXJ0MDsKLQkJc2VyaWFsMSA9ICZ1YXJ0MTsKLQkJc2VyaWFsMiA9ICZ1YXJ0MjsKLQkJc2VyaWFsMyA9ICZ1YXJ0MzsKLQkJc2VyaWFsNCA9ICZ1YXJ0NDsKLQkJc2VyaWFsNSA9ICZ1YXJ0NTsKLQkJc2VyaWFsNiA9ICZ1YXJ0NjsKLQkJc2VyaWFsNyA9ICZ1YXJ0NzsKIAl9OwogCiAJY2hvc2VuIHsKQEAgLTM5LDYgKzMxLDE0IEBACiAJCQkJIDwmYWhiX2dhdGVzIDQ0PjsKIAkJCXN0YXR1cyA9ICJkaXNhYmxlZCI7CiAJCX07CisKKwkJZnJhbWVidWZmZXJAMSB7CisJCQljb21wYXRpYmxlID0gImFsbHdpbm5lcixzaW1wbGUtZnJhbWVidWZmZXIiLCAic2ltcGxlLWZyYW1lYnVmZmVyIjsKKwkJCWFsbHdpbm5lcixwaXBlbGluZSA9ICJkZV9mZTAtZGVfYmUwLWxjZDAtaGRtaSI7CisJCQljbG9ja3MgPSA8JnBsbDUgMT4sIDwmYWhiX2dhdGVzIDM2PiwgPCZhaGJfZ2F0ZXMgNDM+LAorCQkJCSA8JmFoYl9nYXRlcyA0ND4sIDwmYWhiX2dhdGVzIDQ2PjsKKwkJCXN0YXR1cyA9ICJkaXNhYmxlZCI7CisJCX07CiAJfTsKIAogCWNwdXMgewpAQCAtNDM4LDggKzQzOCw4IEBACiAJCQlyZWctbmFtZXMgPSAicGh5X2N0cmwiLCAicG11MSIsICJwbXUyIjsKIAkJCWNsb2NrcyA9IDwmdXNiX2NsayA4PjsKIAkJCWNsb2NrLW5hbWVzID0gInVzYl9waHkiOwotCQkJcmVzZXRzID0gPCZ1c2JfY2xrIDE+LCA8JnVzYl9jbGsgMj47Ci0JCQlyZXNldC1uYW1lcyA9ICJ1c2IxX3Jlc2V0IiwgInVzYjJfcmVzZXQiOworCQkJcmVzZXRzID0gPCZ1c2JfY2xrIDA+LCA8JnVzYl9jbGsgMT4sIDwmdXNiX2NsayAyPjsKKwkJCXJlc2V0LW5hbWVzID0gInVzYjBfcmVzZXQiLCAidXNiMV9yZXNldCIsICJ1c2IyX3Jlc2V0IjsKIAkJCXN0YXR1cyA9ICJkaXNhYmxlZCI7CiAJCX07CiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2Jvb3QvZHRzL3N1bjVpLWExMHMtb2xpbnV4aW5vLW1pY3JvLmR0cyBiL2FyY2gvYXJtL2Jvb3QvZHRzL3N1bjVpLWExMHMtb2xpbnV4aW5vLW1pY3JvLmR0cwppbmRleCBmZTNjNTU5Li5iZmE3NDI4IDEwMDY0NAotLS0gYS9hcmNoL2FybS9ib290L2R0cy9zdW41aS1hMTBzLW9saW51eGluby1taWNyby5kdHMKKysrIGIvYXJjaC9hcm0vYm9vdC9kdHMvc3VuNWktYTEwcy1vbGludXhpbm8tbWljcm8uZHRzCkBAIC01NSw2ICs1NSwxMiBAQAogCW1vZGVsID0gIk9saW1leCBBMTBzLU9saW51eGlubyBNaWNybyI7CiAJY29tcGF0aWJsZSA9ICJvbGltZXgsYTEwcy1vbGludXhpbm8tbWljcm8iLCAiYWxsd2lubmVyLHN1bjVpLWExMHMiOwogCisJYWxpYXNlcyB7CisJCXNlcmlhbDAgPSAmdWFydDA7CisJCXNlcmlhbDEgPSAmdWFydDI7CisJCXNlcmlhbDIgPSAmdWFydDM7CisJfTsKKwogCXNvY0AwMWMwMDAwMCB7CiAJCWVtYWM6IGV0aGVybmV0QDAxYzBiMDAwIHsKIAkJCXBpbmN0cmwtbmFtZXMgPSAiZGVmYXVsdCI7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9ib290L2R0cy9zdW41aS1hMTBzLmR0c2kgYi9hcmNoL2FybS9ib290L2R0cy9zdW41aS1hMTBzLmR0c2kKaW5kZXggMWI3NjY2Ny4uMmU3ZDgyNiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vYm9vdC9kdHMvc3VuNWktYTEwcy5kdHNpCisrKyBiL2FyY2gvYXJtL2Jvb3QvZHRzL3N1bjVpLWExMHMuZHRzaQpAQCAtMTgsMTAgKzE4LDYgQEAKIAogCWFsaWFzZXMgewogCQlldGhlcm5ldDAgPSAmZW1hYzsKLQkJc2VyaWFsMCA9ICZ1YXJ0MDsKLQkJc2VyaWFsMSA9ICZ1YXJ0MTsKLQkJc2VyaWFsMiA9ICZ1YXJ0MjsKLQkJc2VyaWFsMyA9ICZ1YXJ0MzsKIAl9OwogCiAJY2hvc2VuIHsKQEAgLTM5MCw4ICszODYsOCBAQAogCQkJcmVnLW5hbWVzID0gInBoeV9jdHJsIiwgInBtdTEiOwogCQkJY2xvY2tzID0gPCZ1c2JfY2xrIDg+OwogCQkJY2xvY2stbmFtZXMgPSAidXNiX3BoeSI7Ci0JCQlyZXNldHMgPSA8JnVzYl9jbGsgMT47Ci0JCQlyZXNldC1uYW1lcyA9ICJ1c2IxX3Jlc2V0IjsKKwkJCXJlc2V0cyA9IDwmdXNiX2NsayAwPiwgPCZ1c2JfY2xrIDE+OworCQkJcmVzZXQtbmFtZXMgPSAidXNiMF9yZXNldCIsICJ1c2IxX3Jlc2V0IjsKIAkJCXN0YXR1cyA9ICJkaXNhYmxlZCI7CiAJCX07CiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2Jvb3QvZHRzL3N1bjVpLWExMy1oc2ctaDcwMi5kdHMgYi9hcmNoL2FybS9ib290L2R0cy9zdW41aS1hMTMtaHNnLWg3MDIuZHRzCmluZGV4IGVlZWQxZjIuLmM3YmUzYWIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2Jvb3QvZHRzL3N1bjVpLWExMy1oc2ctaDcwMi5kdHMKKysrIGIvYXJjaC9hcm0vYm9vdC9kdHMvc3VuNWktYTEzLWhzZy1oNzAyLmR0cwpAQCAtNTMsNiArNTMsMTAgQEAKIAltb2RlbCA9ICJIU0cgSDcwMiI7CiAJY29tcGF0aWJsZSA9ICJoc2csaDcwMiIsICJhbGx3aW5uZXIsc3VuNWktYTEzIjsKIAorCWFsaWFzZXMgeworCQlzZXJpYWwwID0gJnVhcnQxOworCX07CisKIAlzb2NAMDFjMDAwMDAgewogCQltbWMwOiBtbWNAMDFjMGYwMDAgewogCQkJcGluY3RybC1uYW1lcyA9ICJkZWZhdWx0IjsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2Jvb3QvZHRzL3N1bjVpLWExMy1vbGludXhpbm8tbWljcm8uZHRzIGIvYXJjaC9hcm0vYm9vdC9kdHMvc3VuNWktYTEzLW9saW51eGluby1taWNyby5kdHMKaW5kZXggOTE2ZWU4Yi4uM2RlY2VmYiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vYm9vdC9kdHMvc3VuNWktYTEzLW9saW51eGluby1taWNyby5kdHMKKysrIGIvYXJjaC9hcm0vYm9vdC9kdHMvc3VuNWktYTEzLW9saW51eGluby1taWNyby5kdHMKQEAgLTU0LDYgKzU0LDEwIEBACiAJbW9kZWwgPSAiT2xpbWV4IEExMy1PbGludXhpbm8gTWljcm8iOwogCWNvbXBhdGlibGUgPSAib2xpbWV4LGExMy1vbGludXhpbm8tbWljcm8iLCAiYWxsd2lubmVyLHN1bjVpLWExMyI7CiAKKwlhbGlhc2VzIHsKKwkJc2VyaWFsMCA9ICZ1YXJ0MTsKKwl9OworCiAJc29jQDAxYzAwMDAwIHsKIAkJbW1jMDogbW1jQDAxYzBmMDAwIHsKIAkJCXBpbmN0cmwtbmFtZXMgPSAiZGVmYXVsdCI7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9ib290L2R0cy9zdW41aS1hMTMtb2xpbnV4aW5vLmR0cyBiL2FyY2gvYXJtL2Jvb3QvZHRzL3N1bjVpLWExMy1vbGludXhpbm8uZHRzCmluZGV4IGUzMWQyOTEuLmI0MjFmN2YgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2Jvb3QvZHRzL3N1bjVpLWExMy1vbGludXhpbm8uZHRzCisrKyBiL2FyY2gvYXJtL2Jvb3QvZHRzL3N1bjVpLWExMy1vbGludXhpbm8uZHRzCkBAIC01NSw2ICs1NSwxMCBAQAogCW1vZGVsID0gIk9saW1leCBBMTMtT2xpbnV4aW5vIjsKIAljb21wYXRpYmxlID0gIm9saW1leCxhMTMtb2xpbnV4aW5vIiwgImFsbHdpbm5lcixzdW41aS1hMTMiOwogCisJYWxpYXNlcyB7CisJCXNlcmlhbDAgPSAmdWFydDE7CisJfTsKKwogCXNvY0AwMWMwMDAwMCB7CiAJCW1tYzA6IG1tY0AwMWMwZjAwMCB7CiAJCQlwaW5jdHJsLW5hbWVzID0gImRlZmF1bHQiOwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vYm9vdC9kdHMvc3VuNWktYTEzLmR0c2kgYi9hcmNoL2FybS9ib290L2R0cy9zdW41aS1hMTMuZHRzaQppbmRleCBjMzUyMTdlLi5jNTU2Njg4IDEwMDY0NAotLS0gYS9hcmNoL2FybS9ib290L2R0cy9zdW41aS1hMTMuZHRzaQorKysgYi9hcmNoL2FybS9ib290L2R0cy9zdW41aS1hMTMuZHRzaQpAQCAtMTYsMTEgKzE2LDYgQEAKIC8gewogCWludGVycnVwdC1wYXJlbnQgPSA8JmludGM+OwogCi0JYWxpYXNlcyB7Ci0JCXNlcmlhbDAgPSAmdWFydDE7Ci0JCXNlcmlhbDEgPSAmdWFydDM7Ci0JfTsKLQogCWNwdXMgewogCQkjYWRkcmVzcy1jZWxscyA9IDwxPjsKIAkJI3NpemUtY2VsbHMgPSA8MD47CkBAIC0zNDksOCArMzQ0LDggQEAKIAkJCXJlZy1uYW1lcyA9ICJwaHlfY3RybCIsICJwbXUxIjsKIAkJCWNsb2NrcyA9IDwmdXNiX2NsayA4PjsKIAkJCWNsb2NrLW5hbWVzID0gInVzYl9waHkiOwotCQkJcmVzZXRzID0gPCZ1c2JfY2xrIDE+OwotCQkJcmVzZXQtbmFtZXMgPSAidXNiMV9yZXNldCI7CisJCQlyZXNldHMgPSA8JnVzYl9jbGsgMD4sIDwmdXNiX2NsayAxPjsKKwkJCXJlc2V0LW5hbWVzID0gInVzYjBfcmVzZXQiLCAidXNiMV9yZXNldCI7CiAJCQlzdGF0dXMgPSAiZGlzYWJsZWQiOwogCQl9OwogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9ib290L2R0cy9zdW42aS1hMzEuZHRzaSBiL2FyY2gvYXJtL2Jvb3QvZHRzL3N1bjZpLWEzMS5kdHNpCmluZGV4IGY0NzE1NmIuLjFlN2U3YmMgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2Jvb3QvZHRzL3N1bjZpLWEzMS5kdHNpCisrKyBiL2FyY2gvYXJtL2Jvb3QvZHRzL3N1bjZpLWEzMS5kdHNpCkBAIC01MywxMiArNTMsNiBAQAogCWludGVycnVwdC1wYXJlbnQgPSA8JmdpYz47CiAKIAlhbGlhc2VzIHsKLQkJc2VyaWFsMCA9ICZ1YXJ0MDsKLQkJc2VyaWFsMSA9ICZ1YXJ0MTsKLQkJc2VyaWFsMiA9ICZ1YXJ0MjsKLQkJc2VyaWFsMyA9ICZ1YXJ0MzsKLQkJc2VyaWFsNCA9ICZ1YXJ0NDsKLQkJc2VyaWFsNSA9ICZ1YXJ0NTsKIAkJZXRoZXJuZXQwID0gJmdtYWM7CiAJfTsKIApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vYm9vdC9kdHMvc3VuN2ktYTIwLWJhbmFuYXBpLmR0cyBiL2FyY2gvYXJtL2Jvb3QvZHRzL3N1bjdpLWEyMC1iYW5hbmFwaS5kdHMKaW5kZXggMWNmMTIxNC4uYmQ3YjE1YSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vYm9vdC9kdHMvc3VuN2ktYTIwLWJhbmFuYXBpLmR0cworKysgYi9hcmNoL2FybS9ib290L2R0cy9zdW43aS1hMjAtYmFuYW5hcGkuZHRzCkBAIC01NSw2ICs1NSwxMiBAQAogCW1vZGVsID0gIkxlTWFrZXIgQmFuYW5hIFBpIjsKIAljb21wYXRpYmxlID0gImxlbWFrZXIsYmFuYW5hcGkiLCAiYWxsd2lubmVyLHN1bjdpLWEyMCI7CiAKKwlhbGlhc2VzIHsKKwkJc2VyaWFsMCA9ICZ1YXJ0MDsKKwkJc2VyaWFsMSA9ICZ1YXJ0MzsKKwkJc2VyaWFsMiA9ICZ1YXJ0NzsKKwl9OworCiAJc29jQDAxYzAwMDAwIHsKIAkJc3BpMDogc3BpQDAxYzA1MDAwIHsKIAkJCXBpbmN0cmwtbmFtZXMgPSAiZGVmYXVsdCI7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9ib290L2R0cy9zdW43aS1hMjAtaHVtbWluZ2JpcmQuZHRzIGIvYXJjaC9hcm0vYm9vdC9kdHMvc3VuN2ktYTIwLWh1bW1pbmdiaXJkLmR0cwppbmRleCAwZTRiZmEzLi4wYmNlZmNiIDEwMDY0NAotLS0gYS9hcmNoL2FybS9ib290L2R0cy9zdW43aS1hMjAtaHVtbWluZ2JpcmQuZHRzCisrKyBiL2FyY2gvYXJtL2Jvb3QvZHRzL3N1bjdpLWEyMC1odW1taW5nYmlyZC5kdHMKQEAgLTE5LDYgKzE5LDE0IEBACiAJbW9kZWwgPSAiTWVycmlpIEEyMCBIdW1taW5nYmlyZCI7CiAJY29tcGF0aWJsZSA9ICJtZXJyaWksYTIwLWh1bW1pbmdiaXJkIiwgImFsbHdpbm5lcixzdW43aS1hMjAiOwogCisJYWxpYXNlcyB7CisJCXNlcmlhbDAgPSAmdWFydDA7CisJCXNlcmlhbDEgPSAmdWFydDI7CisJCXNlcmlhbDIgPSAmdWFydDM7CisJCXNlcmlhbDMgPSAmdWFydDQ7CisJCXNlcmlhbDQgPSAmdWFydDU7CisJfTsKKwogCXNvY0AwMWMwMDAwMCB7CiAJCW1tYzA6IG1tY0AwMWMwZjAwMCB7CiAJCQlwaW5jdHJsLW5hbWVzID0gImRlZmF1bHQiOwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vYm9vdC9kdHMvc3VuN2ktYTIwLW9saW51eGluby1taWNyby5kdHMgYi9hcmNoL2FybS9ib290L2R0cy9zdW43aS1hMjAtb2xpbnV4aW5vLW1pY3JvLmR0cwppbmRleCA5ZDY2OWNkZi4uNjZjYzc3NyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vYm9vdC9kdHMvc3VuN2ktYTIwLW9saW51eGluby1taWNyby5kdHMKKysrIGIvYXJjaC9hcm0vYm9vdC9kdHMvc3VuN2ktYTIwLW9saW51eGluby1taWNyby5kdHMKQEAgLTIwLDYgKzIwLDkgQEAKIAljb21wYXRpYmxlID0gIm9saW1leCxhMjAtb2xpbnV4aW5vLW1pY3JvIiwgImFsbHdpbm5lcixzdW43aS1hMjAiOwogCiAJYWxpYXNlcyB7CisJCXNlcmlhbDAgPSAmdWFydDA7CisJCXNlcmlhbDEgPSAmdWFydDY7CisJCXNlcmlhbDIgPSAmdWFydDc7CiAJCXNwaTAgPSAmc3BpMTsKIAkJc3BpMSA9ICZzcGkyOwogCX07CmRpZmYgLS1naXQgYS9hcmNoL2FybS9ib290L2R0cy9zdW43aS1hMjAuZHRzaSBiL2FyY2gvYXJtL2Jvb3QvZHRzL3N1bjdpLWEyMC5kdHNpCmluZGV4IGUyMWNlNTkuLjg5NzQ5Y2UgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2Jvb3QvZHRzL3N1bjdpLWEyMC5kdHNpCisrKyBiL2FyY2gvYXJtL2Jvb3QvZHRzL3N1bjdpLWEyMC5kdHNpCkBAIC01NCwxNCArNTQsNiBAQAogCiAJYWxpYXNlcyB7CiAJCWV0aGVybmV0MCA9ICZnbWFjOwotCQlzZXJpYWwwID0gJnVhcnQwOwotCQlzZXJpYWwxID0gJnVhcnQxOwotCQlzZXJpYWwyID0gJnVhcnQyOwotCQlzZXJpYWwzID0gJnVhcnQzOwotCQlzZXJpYWw0ID0gJnVhcnQ0OwotCQlzZXJpYWw1ID0gJnVhcnQ1OwotCQlzZXJpYWw2ID0gJnVhcnQ2OwotCQlzZXJpYWw3ID0gJnVhcnQ3OwogCX07CiAKIAljaG9zZW4gewpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vYm9vdC9kdHMvc3VuOGktYTIzLWlwcG8tcThoLXY1LmR0cyBiL2FyY2gvYXJtL2Jvb3QvZHRzL3N1bjhpLWEyMy1pcHBvLXE4aC12NS5kdHMKaW5kZXggN2YyMTE3Yy4uMzJhZDgwOCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vYm9vdC9kdHMvc3VuOGktYTIzLWlwcG8tcThoLXY1LmR0cworKysgYi9hcmNoL2FybS9ib290L2R0cy9zdW44aS1hMjMtaXBwby1xOGgtdjUuZHRzCkBAIC01NSw2ICs1NSwxMCBAQAogCW1vZGVsID0gIklwcG8gUThIIER1YWwgQ29yZSBUYWJsZXQgKHY1KSI7CiAJY29tcGF0aWJsZSA9ICJpcHBvLHE4aC12NSIsICJhbGx3aW5uZXIsc3VuOGktYTIzIjsKIAorCWFsaWFzZXMgeworCQlzZXJpYWwwID0gJnJfdWFydDsKKwl9OworCiAJY2hvc2VuIHsKIAkJYm9vdGFyZ3MgPSAiZWFybHlwcmludGsgY29uc29sZT10dHlTMCwxMTUyMDAiOwogCX07CmRpZmYgLS1naXQgYS9hcmNoL2FybS9ib290L2R0cy9zdW44aS1hMjMuZHRzaSBiL2FyY2gvYXJtL2Jvb3QvZHRzL3N1bjhpLWEyMy5kdHNpCmluZGV4IDA3NDZjZDEuLjg2NTg0ZmMgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2Jvb3QvZHRzL3N1bjhpLWEyMy5kdHNpCisrKyBiL2FyY2gvYXJtL2Jvb3QvZHRzL3N1bjhpLWEyMy5kdHNpCkBAIC01MiwxNSArNTIsNiBAQAogLyB7CiAJaW50ZXJydXB0LXBhcmVudCA9IDwmZ2ljPjsKIAotCWFsaWFzZXMgewotCQlzZXJpYWwwID0gJnVhcnQwOwotCQlzZXJpYWwxID0gJnVhcnQxOwotCQlzZXJpYWwyID0gJnVhcnQyOwotCQlzZXJpYWwzID0gJnVhcnQzOwotCQlzZXJpYWw0ID0gJnVhcnQ0OwotCQlzZXJpYWw1ID0gJnJfdWFydDsKLQl9OwotCiAJY3B1cyB7CiAJCSNhZGRyZXNzLWNlbGxzID0gPDE+OwogCQkjc2l6ZS1jZWxscyA9IDwwPjsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2Jvb3QvZHRzL3N1bjlpLWE4MC1vcHRpbXVzLmR0cyBiL2FyY2gvYXJtL2Jvb3QvZHRzL3N1bjlpLWE4MC1vcHRpbXVzLmR0cwppbmRleCA1MDY5NDhmLi4xMWVjNzEwIDEwMDY0NAotLS0gYS9hcmNoL2FybS9ib290L2R0cy9zdW45aS1hODAtb3B0aW11cy5kdHMKKysrIGIvYXJjaC9hcm0vYm9vdC9kdHMvc3VuOWktYTgwLW9wdGltdXMuZHRzCkBAIC01NCw2ICs1NCwxMSBAQAogCW1vZGVsID0gIk1lcnJpaSBBODAgT3B0aW11cyBCb2FyZCI7CiAJY29tcGF0aWJsZSA9ICJtZXJyaWksYTgwLW9wdGltdXMiLCAiYWxsd2lubmVyLHN1bjlpLWE4MCI7CiAKKwlhbGlhc2VzIHsKKwkJc2VyaWFsMCA9ICZ1YXJ0MDsKKwkJc2VyaWFsMSA9ICZ1YXJ0NDsKKwl9OworCiAJY2hvc2VuIHsKIAkJYm9vdGFyZ3MgPSAiZWFybHlwcmludGsgY29uc29sZT10dHlTMCwxMTUyMDAiOwogCX07CmRpZmYgLS1naXQgYS9hcmNoL2FybS9ib290L2R0cy9zdW45aS1hODAuZHRzaSBiL2FyY2gvYXJtL2Jvb3QvZHRzL3N1bjlpLWE4MC5kdHNpCmluZGV4IDQ5NDcxNGYuLjllZjQ0MzgyIDEwMDY0NAotLS0gYS9hcmNoL2FybS9ib290L2R0cy9zdW45aS1hODAuZHRzaQorKysgYi9hcmNoL2FybS9ib290L2R0cy9zdW45aS1hODAuZHRzaQpAQCAtNTIsMTYgKzUyLDYgQEAKIC8gewogCWludGVycnVwdC1wYXJlbnQgPSA8JmdpYz47CiAKLQlhbGlhc2VzIHsKLQkJc2VyaWFsMCA9ICZ1YXJ0MDsKLQkJc2VyaWFsMSA9ICZ1YXJ0MTsKLQkJc2VyaWFsMiA9ICZ1YXJ0MjsKLQkJc2VyaWFsMyA9ICZ1YXJ0MzsKLQkJc2VyaWFsNCA9ICZ1YXJ0NDsKLQkJc2VyaWFsNSA9ICZ1YXJ0NTsKLQkJc2VyaWFsNiA9ICZyX3VhcnQ7Ci0JfTsKLQogCWNwdXMgewogCQkjYWRkcmVzcy1jZWxscyA9IDwxPjsKIAkJI3NpemUtY2VsbHMgPSA8MD47CmRpZmYgLS1naXQgYS9hcmNoL2FybS9ib290L2R0cy90ZWdyYTIwLXNlYWJvYXJkLmR0cyBiL2FyY2gvYXJtL2Jvb3QvZHRzL3RlZ3JhMjAtc2VhYm9hcmQuZHRzCmluZGV4IGVhMjgyYzcuLmUyZmVkMjcgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2Jvb3QvZHRzL3RlZ3JhMjAtc2VhYm9hcmQuZHRzCisrKyBiL2FyY2gvYXJtL2Jvb3QvZHRzL3RlZ3JhMjAtc2VhYm9hcmQuZHRzCkBAIC00MDYsNyArNDA2LDcgQEAKIAkJY2xvY2stZnJlcXVlbmN5ID0gPDQwMDAwMD47CiAKIAkJbWFnbmV0b21ldGVyQGMgewotCQkJY29tcGF0aWJsZSA9ICJhayxhazg5NzUiOworCQkJY29tcGF0aWJsZSA9ICJhc2FoaS1rYXNlaSxhazg5NzUiOwogCQkJcmVnID0gPDB4Yz47CiAJCQlpbnRlcnJ1cHQtcGFyZW50ID0gPCZncGlvPjsKIAkJCWludGVycnVwdHMgPSA8VEVHUkFfR1BJTyhOLCA1KSBJUlFfVFlQRV9MRVZFTF9ISUdIPjsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2t2bV9lbXVsYXRlLmggYi9hcmNoL2FybS9pbmNsdWRlL2FzbS9rdm1fZW11bGF0ZS5oCmluZGV4IDY2Y2UxNzYuLjdiMDE1MjMgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2t2bV9lbXVsYXRlLmgKKysrIGIvYXJjaC9hcm0vaW5jbHVkZS9hc20va3ZtX2VtdWxhdGUuaApAQCAtMzgsNiArMzgsMTYgQEAKIAl2Y3B1LT5hcmNoLmhjciA9IEhDUl9HVUVTVF9NQVNLOwogfQogCitzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGxvbmcgdmNwdV9nZXRfaGNyKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSkKK3sKKwlyZXR1cm4gdmNwdS0+YXJjaC5oY3I7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCB2Y3B1X3NldF9oY3Ioc3RydWN0IGt2bV92Y3B1ICp2Y3B1LCB1bnNpZ25lZCBsb25nIGhjcikKK3sKKwl2Y3B1LT5hcmNoLmhjciA9IGhjcjsKK30KKwogc3RhdGljIGlubGluZSBib29sIHZjcHVfbW9kZV9pc18zMmJpdChzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpCiB7CiAJcmV0dXJuIDE7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9pbmNsdWRlL2FzbS9rdm1faG9zdC5oIGIvYXJjaC9hcm0vaW5jbHVkZS9hc20va3ZtX2hvc3QuaAppbmRleCAyNTRlMDY1Li4wNGI0ZWEwIDEwMDY0NAotLS0gYS9hcmNoL2FybS9pbmNsdWRlL2FzbS9rdm1faG9zdC5oCisrKyBiL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2t2bV9ob3N0LmgKQEAgLTEyNSw5ICsxMjUsNiBAQAogCSAqIEFueXRoaW5nIHRoYXQgaXMgbm90IHVzZWQgZGlyZWN0bHkgZnJvbSBhc3NlbWJseSBjb2RlIGdvZXMKIAkgKiBoZXJlLgogCSAqLwotCS8qIGRjYWNoZSBzZXQvd2F5IG9wZXJhdGlvbiBwZW5kaW5nICovCi0JaW50IGxhc3RfcGNwdTsKLQljcHVtYXNrX3QgcmVxdWlyZV9kY2FjaGVfZmx1c2g7CiAKIAkvKiBEb24ndCBydW4gdGhlIGd1ZXN0IG9uIHRoaXMgdmNwdSAqLwogCWJvb2wgcGF1c2U7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9pbmNsdWRlL2FzbS9rdm1fbW11LmggYi9hcmNoL2FybS9pbmNsdWRlL2FzbS9rdm1fbW11LmgKaW5kZXggNjNlMGVjYy4uMWJjYThmOCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vaW5jbHVkZS9hc20va3ZtX21tdS5oCisrKyBiL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2t2bV9tbXUuaApAQCAtNDQsNiArNDQsNyBAQAogCiAjaWZuZGVmIF9fQVNTRU1CTFlfXwogCisjaW5jbHVkZSA8bGludXgvaGlnaG1lbS5oPgogI2luY2x1ZGUgPGFzbS9jYWNoZWZsdXNoLmg+CiAjaW5jbHVkZSA8YXNtL3BnYWxsb2MuaD4KIApAQCAtMTYxLDEzICsxNjIsMTAgQEAKIAlyZXR1cm4gKHZjcHUtPmFyY2guY3AxNVtjMV9TQ1RMUl0gJiAwYjEwMSkgPT0gMGIxMDE7CiB9CiAKLXN0YXRpYyBpbmxpbmUgdm9pZCBjb2hlcmVudF9jYWNoZV9ndWVzdF9wYWdlKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwgaHZhX3QgaHZhLAotCQkJCQkgICAgIHVuc2lnbmVkIGxvbmcgc2l6ZSwKLQkJCQkJICAgICBib29sIGlwYV91bmNhY2hlZCkKK3N0YXRpYyBpbmxpbmUgdm9pZCBfX2NvaGVyZW50X2NhY2hlX2d1ZXN0X3BhZ2Uoc3RydWN0IGt2bV92Y3B1ICp2Y3B1LCBwZm5fdCBwZm4sCisJCQkJCSAgICAgICB1bnNpZ25lZCBsb25nIHNpemUsCisJCQkJCSAgICAgICBib29sIGlwYV91bmNhY2hlZCkKIHsKLQlpZiAoIXZjcHVfaGFzX2NhY2hlX2VuYWJsZWQodmNwdSkgfHwgaXBhX3VuY2FjaGVkKQotCQlrdm1fZmx1c2hfZGNhY2hlX3RvX3BvYygodm9pZCAqKWh2YSwgc2l6ZSk7Ci0JCiAJLyoKIAkgKiBJZiB3ZSBhcmUgZ29pbmcgdG8gaW5zZXJ0IGFuIGluc3RydWN0aW9uIHBhZ2UgYW5kIHRoZSBpY2FjaGUgaXMKIAkgKiBlaXRoZXIgVklQVCBvciBQSVBULCB0aGVyZSBpcyBhIHBvdGVudGlhbCBwcm9ibGVtIHdoZXJlIHRoZSBob3N0CkBAIC0xNzksMTggKzE3Nyw3NyBAQAogCSAqCiAJICogVklWVCBjYWNoZXMgYXJlIHRhZ2dlZCB1c2luZyBib3RoIHRoZSBBU0lEIGFuZCB0aGUgVk1JRCBhbmQgZG9lc24ndAogCSAqIG5lZWQgYW55IGtpbmQgb2YgZmx1c2hpbmcgKERESSAwNDA2Qy5iIC0gUGFnZSBCMy0xMzkyKS4KKwkgKgorCSAqIFdlIG5lZWQgdG8gZG8gdGhpcyB0aHJvdWdoIGEga2VybmVsIG1hcHBpbmcgKHVzaW5nIHRoZQorCSAqIHVzZXItc3BhY2UgbWFwcGluZyBoYXMgcHJvdmVkIHRvIGJlIHRoZSB3cm9uZworCSAqIHNvbHV0aW9uKS4gRm9yIHRoYXQsIHdlIG5lZWQgdG8ga21hcCBvbmUgcGFnZSBhdCBhIHRpbWUsCisJICogYW5kIGl0ZXJhdGUgb3ZlciB0aGUgcmFuZ2UuCiAJICovCi0JaWYgKGljYWNoZV9pc19waXB0KCkpIHsKLQkJX19jcHVjX2NvaGVyZW50X3VzZXJfcmFuZ2UoaHZhLCBodmEgKyBzaXplKTsKLQl9IGVsc2UgaWYgKCFpY2FjaGVfaXNfdml2dF9hc2lkX3RhZ2dlZCgpKSB7CisKKwlib29sIG5lZWRfZmx1c2ggPSAhdmNwdV9oYXNfY2FjaGVfZW5hYmxlZCh2Y3B1KSB8fCBpcGFfdW5jYWNoZWQ7CisKKwlWTV9CVUdfT04oc2l6ZSAmIFBBR0VfTUFTSyk7CisKKwlpZiAoIW5lZWRfZmx1c2ggJiYgIWljYWNoZV9pc19waXB0KCkpCisJCWdvdG8gdmlwdF9jYWNoZTsKKworCXdoaWxlIChzaXplKSB7CisJCXZvaWQgKnZhID0ga21hcF9hdG9taWNfcGZuKHBmbik7CisKKwkJaWYgKG5lZWRfZmx1c2gpCisJCQlrdm1fZmx1c2hfZGNhY2hlX3RvX3BvYyh2YSwgUEFHRV9TSVpFKTsKKworCQlpZiAoaWNhY2hlX2lzX3BpcHQoKSkKKwkJCV9fY3B1Y19jb2hlcmVudF91c2VyX3JhbmdlKCh1bnNpZ25lZCBsb25nKXZhLAorCQkJCQkJICAgKHVuc2lnbmVkIGxvbmcpdmEgKyBQQUdFX1NJWkUpOworCisJCXNpemUgLT0gUEFHRV9TSVpFOworCQlwZm4rKzsKKworCQlrdW5tYXBfYXRvbWljKHZhKTsKKwl9CisKK3ZpcHRfY2FjaGU6CisJaWYgKCFpY2FjaGVfaXNfcGlwdCgpICYmICFpY2FjaGVfaXNfdml2dF9hc2lkX3RhZ2dlZCgpKSB7CiAJCS8qIGFueSBraW5kIG9mIFZJUFQgY2FjaGUgKi8KIAkJX19mbHVzaF9pY2FjaGVfYWxsKCk7CiAJfQogfQogCitzdGF0aWMgaW5saW5lIHZvaWQgX19rdm1fZmx1c2hfZGNhY2hlX3B0ZShwdGVfdCBwdGUpCit7CisJdm9pZCAqdmEgPSBrbWFwX2F0b21pYyhwdGVfcGFnZShwdGUpKTsKKworCWt2bV9mbHVzaF9kY2FjaGVfdG9fcG9jKHZhLCBQQUdFX1NJWkUpOworCisJa3VubWFwX2F0b21pYyh2YSk7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBfX2t2bV9mbHVzaF9kY2FjaGVfcG1kKHBtZF90IHBtZCkKK3sKKwl1bnNpZ25lZCBsb25nIHNpemUgPSBQTURfU0laRTsKKwlwZm5fdCBwZm4gPSBwbWRfcGZuKHBtZCk7CisKKwl3aGlsZSAoc2l6ZSkgeworCQl2b2lkICp2YSA9IGttYXBfYXRvbWljX3BmbihwZm4pOworCisJCWt2bV9mbHVzaF9kY2FjaGVfdG9fcG9jKHZhLCBQQUdFX1NJWkUpOworCisJCXBmbisrOworCQlzaXplIC09IFBBR0VfU0laRTsKKworCQlrdW5tYXBfYXRvbWljKHZhKTsKKwl9Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBfX2t2bV9mbHVzaF9kY2FjaGVfcHVkKHB1ZF90IHB1ZCkKK3sKK30KKwogI2RlZmluZSBrdm1fdmlydF90b19waHlzKHgpCQl2aXJ0X3RvX2lkbWFwKCh1bnNpZ25lZCBsb25nKSh4KSkKIAotdm9pZCBzdGFnZTJfZmx1c2hfdm0oc3RydWN0IGt2bSAqa3ZtKTsKK3ZvaWQga3ZtX3NldF93YXlfZmx1c2goc3RydWN0IGt2bV92Y3B1ICp2Y3B1KTsKK3ZvaWQga3ZtX3RvZ2dsZV9jYWNoZShzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUsIGJvb2wgd2FzX2VuYWJsZWQpOwogCiAjZW5kaWYJLyogIV9fQVNTRU1CTFlfXyAqLwogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9rZXJuZWwvYmlvczMyLmMgYi9hcmNoL2FybS9rZXJuZWwvYmlvczMyLmMKaW5kZXggYTRlZmZkNi4uMDE2OTkxNyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0va2VybmVsL2Jpb3MzMi5jCisrKyBiL2FyY2gvYXJtL2tlcm5lbC9iaW9zMzIuYwpAQCAtNDIyLDE3ICs0MjIsMTYgQEAKIHN0YXRpYyBpbnQgcGNpYmlvc19pbml0X3Jlc291cmNlcyhpbnQgYnVzbnIsIHN0cnVjdCBwY2lfc3lzX2RhdGEgKnN5cykKIHsKIAlpbnQgcmV0OwotCXN0cnVjdCBwY2lfaG9zdF9icmlkZ2Vfd2luZG93ICp3aW5kb3c7CisJc3RydWN0IHJlc291cmNlX2VudHJ5ICp3aW5kb3c7CiAKIAlpZiAobGlzdF9lbXB0eSgmc3lzLT5yZXNvdXJjZXMpKSB7CiAJCXBjaV9hZGRfcmVzb3VyY2Vfb2Zmc2V0KCZzeXMtPnJlc291cmNlcywKIAkJCSAmaW9tZW1fcmVzb3VyY2UsIHN5cy0+bWVtX29mZnNldCk7CiAJfQogCi0JbGlzdF9mb3JfZWFjaF9lbnRyeSh3aW5kb3csICZzeXMtPnJlc291cmNlcywgbGlzdCkgeworCXJlc291cmNlX2xpc3RfZm9yX2VhY2hfZW50cnkod2luZG93LCAmc3lzLT5yZXNvdXJjZXMpCiAJCWlmIChyZXNvdXJjZV90eXBlKHdpbmRvdy0+cmVzKSA9PSBJT1JFU09VUkNFX0lPKQogCQkJcmV0dXJuIDA7Ci0JfQogCiAJc3lzLT5pb19yZXMuc3RhcnQgPSAoYnVzbnIgKiBTWl82NEspID8gIDogcGNpYmlvc19taW5faW87CiAJc3lzLT5pb19yZXMuZW5kID0gKGJ1c25yICsgMSkgKiBTWl82NEsgLSAxOwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0va2VybmVsL2VudHJ5LWhlYWRlci5TIGIvYXJjaC9hcm0va2VybmVsL2VudHJ5LWhlYWRlci5TCmluZGV4IDQxNzZkZjcuLjFhMDA0NWEgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2tlcm5lbC9lbnRyeS1oZWFkZXIuUworKysgYi9hcmNoL2FybS9rZXJuZWwvZW50cnktaGVhZGVyLlMKQEAgLTI1MywyMSArMjUzLDIyIEBACiAJLmVuZG0KIAogCS5tYWNybwlyZXN0b3JlX3VzZXJfcmVncywgZmFzdCA9IDAsIG9mZnNldCA9IDAKLQlsZHIJcjEsIFtzcCwgI1xvZmZzZXQgKyBTX1BTUl0JQCBnZXQgY2FsbGluZyBjcHNyCi0JbGRyCWxyLCBbc3AsICNcb2Zmc2V0ICsgU19QQ10hCUAgZ2V0IHBjCisJbW92CXIyLCBzcAorCWxkcglyMSwgW3IyLCAjXG9mZnNldCArIFNfUFNSXQlAIGdldCBjYWxsaW5nIGNwc3IKKwlsZHIJbHIsIFtyMiwgI1xvZmZzZXQgKyBTX1BDXSEJQCBnZXQgcGMKIAltc3IJc3Bzcl9jeHNmLCByMQkJCUAgc2F2ZSBpbiBzcHNyX3N2YwogI2lmIGRlZmluZWQoQ09ORklHX0NQVV9WNikgfHwgZGVmaW5lZChDT05GSUdfQ1BVXzMydjZLKQogCUAgV2UgbXVzdCBhdm9pZCBjbHJleCBkdWUgdG8gQ29ydGV4LUExNSBlcnJhdHVtICM4MzAzMjEKLQlzdHJleAlyMSwgcjIsIFtzcF0JCQlAIGNsZWFyIHRoZSBleGNsdXNpdmUgbW9uaXRvcgorCXN0cmV4CXIxLCByMiwgW3IyXQkJCUAgY2xlYXIgdGhlIGV4Y2x1c2l2ZSBtb25pdG9yCiAjZW5kaWYKIAkuaWYJXGZhc3QKLQlsZG1kYglzcCwge3IxIC0gbHJ9XgkJCUAgZ2V0IGNhbGxpbmcgcjEgLSBscgorCWxkbWRiCXIyLCB7cjEgLSBscn1eCQkJQCBnZXQgY2FsbGluZyByMSAtIGxyCiAJLmVsc2UKLQlsZG1kYglzcCwge3IwIC0gbHJ9XgkJCUAgZ2V0IGNhbGxpbmcgcjAgLSBscgorCWxkbWRiCXIyLCB7cjAgLSBscn1eCQkJQCBnZXQgY2FsbGluZyByMCAtIGxyCiAJLmVuZGlmCiAJbW92CXIwLCByMAkJCQlAIEFSTXY1VCBhbmQgZWFybGllciByZXF1aXJlIGEgbm9wCiAJCQkJCQlAIGFmdGVyIGxkbSB7fV4KLQlhZGQJc3AsIHNwLCAjU19GUkFNRV9TSVpFIC0gU19QQworCWFkZAlzcCwgc3AsICNcb2Zmc2V0ICsgU19GUkFNRV9TSVpFCiAJbW92cwlwYywgbHIJCQkJQCByZXR1cm4gJiBtb3ZlIHNwc3Jfc3ZjIGludG8gY3BzcgogCS5lbmRtCiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2tlcm5lbC9lbnRyeS12N20uUyBiL2FyY2gvYXJtL2tlcm5lbC9lbnRyeS12N20uUwppbmRleCAyMjYwZjE4Li44OTQ0ZjQ5IDEwMDY0NAotLS0gYS9hcmNoL2FybS9rZXJuZWwvZW50cnktdjdtLlMKKysrIGIvYXJjaC9hcm0va2VybmVsL2VudHJ5LXY3bS5TCkBAIC0yMiwxMCArMjIsMTIgQEAKIAogX19pbnZhbGlkX2VudHJ5OgogCXY3bV9leGNlcHRpb25fZW50cnkKKyNpZmRlZiBDT05GSUdfUFJJTlRLCiAJYWRyCXIwLCBzdHJlcnIKIAltcnMJcjEsIGlwc3IKIAltb3YJcjIsIGxyCiAJYmwJcHJpbnRrCisjZW5kaWYKIAltb3YJcjAsIHNwCiAJYmwJc2hvd19yZWdzCiAxOgliCTFiCmRpZmYgLS1naXQgYS9hcmNoL2FybS9rZXJuZWwvcGVyZl9ldmVudC5jIGIvYXJjaC9hcm0va2VybmVsL3BlcmZfZXZlbnQuYwppbmRleCBmN2M2NWFkLi41NTdlMTI4IDEwMDY0NAotLS0gYS9hcmNoL2FybS9rZXJuZWwvcGVyZl9ldmVudC5jCisrKyBiL2FyY2gvYXJtL2tlcm5lbC9wZXJmX2V2ZW50LmMKQEAgLTExNiw4ICsxMTYsMTQgQEAKIAkJcmV0ID0gMTsKIAl9CiAKLQlpZiAobGVmdCA+IChzNjQpYXJtcG11LT5tYXhfcGVyaW9kKQotCQlsZWZ0ID0gYXJtcG11LT5tYXhfcGVyaW9kOworCS8qCisJICogTGltaXQgdGhlIG1heGltdW0gcGVyaW9kIHRvIHByZXZlbnQgdGhlIGNvdW50ZXIgdmFsdWUKKwkgKiBmcm9tIG92ZXJ0YWtpbmcgdGhlIG9uZSB3ZSBhcmUgYWJvdXQgdG8gcHJvZ3JhbS4gSW4KKwkgKiBlZmZlY3Qgd2UgYXJlIHJlZHVjaW5nIG1heF9wZXJpb2QgdG8gYWNjb3VudCBmb3IKKwkgKiBpbnRlcnJ1cHQgbGF0ZW5jeSAoYW5kIHdlIGFyZSBiZWluZyB2ZXJ5IGNvbnNlcnZhdGl2ZSkuCisJICovCisJaWYgKGxlZnQgPiAoYXJtcG11LT5tYXhfcGVyaW9kID4+IDEpKQorCQlsZWZ0ID0gYXJtcG11LT5tYXhfcGVyaW9kID4+IDE7CiAKIAlsb2NhbDY0X3NldCgmaHdjLT5wcmV2X2NvdW50LCAodTY0KS1sZWZ0KTsKIApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0va2VybmVsL3NldHVwLmMgYi9hcmNoL2FybS9rZXJuZWwvc2V0dXAuYwppbmRleCA3MTVhZTE5Li5lNTU0MDhlIDEwMDY0NAotLS0gYS9hcmNoL2FybS9rZXJuZWwvc2V0dXAuYworKysgYi9hcmNoL2FybS9rZXJuZWwvc2V0dXAuYwpAQCAtNjU3LDEwICs2NTcsMTMgQEAKIAogCS8qCiAJICogRW5zdXJlIHRoYXQgc3RhcnQvc2l6ZSBhcmUgYWxpZ25lZCB0byBhIHBhZ2UgYm91bmRhcnkuCi0JICogU2l6ZSBpcyBhcHByb3ByaWF0ZWx5IHJvdW5kZWQgZG93biwgc3RhcnQgaXMgcm91bmRlZCB1cC4KKwkgKiBTaXplIGlzIHJvdW5kZWQgZG93biwgc3RhcnQgaXMgcm91bmRlZCB1cC4KIAkgKi8KLQlzaXplIC09IHN0YXJ0ICYgflBBR0VfTUFTSzsKIAlhbGlnbmVkX3N0YXJ0ID0gUEFHRV9BTElHTihzdGFydCk7CisJaWYgKGFsaWduZWRfc3RhcnQgPiBzdGFydCArIHNpemUpCisJCXNpemUgPSAwOworCWVsc2UKKwkJc2l6ZSAtPSBhbGlnbmVkX3N0YXJ0IC0gc3RhcnQ7CiAKICNpZm5kZWYgQ09ORklHX0FSQ0hfUEhZU19BRERSX1RfNjRCSVQKIAlpZiAoYWxpZ25lZF9zdGFydCA+IFVMT05HX01BWCkgewpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0va3ZtL2FybS5jIGIvYXJjaC9hcm0va3ZtL2FybS5jCmluZGV4IDJkNmQ5MTAuLjBiMGQ1OGEgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2t2bS9hcm0uYworKysgYi9hcmNoL2FybS9rdm0vYXJtLmMKQEAgLTI4MSwxNSArMjgxLDYgQEAKIAl2Y3B1LT5jcHUgPSBjcHU7CiAJdmNwdS0+YXJjaC5ob3N0X2NwdV9jb250ZXh0ID0gdGhpc19jcHVfcHRyKGt2bV9ob3N0X2NwdV9zdGF0ZSk7CiAKLQkvKgotCSAqIENoZWNrIHdoZXRoZXIgdGhpcyB2Y3B1IHJlcXVpcmVzIHRoZSBjYWNoZSB0byBiZSBmbHVzaGVkIG9uCi0JICogdGhpcyBwaHlzaWNhbCBDUFUuIFRoaXMgaXMgYSBjb25zZXF1ZW5jZSBvZiBkb2luZyBkY2FjaGUKLQkgKiBvcGVyYXRpb25zIGJ5IHNldC93YXkgb24gdGhpcyB2Y3B1LiBXZSBkbyBpdCBoZXJlIHRvIGJlIGluCi0JICogYSBub24tcHJlZW1wdGlibGUgc2VjdGlvbi4KLQkgKi8KLQlpZiAoY3B1bWFza190ZXN0X2FuZF9jbGVhcl9jcHUoY3B1LCAmdmNwdS0+YXJjaC5yZXF1aXJlX2RjYWNoZV9mbHVzaCkpCi0JCWZsdXNoX2NhY2hlX2FsbCgpOyAvKiBXZSdkIHJlYWxseSB3YW50IHY3X2ZsdXNoX2RjYWNoZV9hbGwoKSAqLwotCiAJa3ZtX2FybV9zZXRfcnVubmluZ192Y3B1KHZjcHUpOwogfQogCkBAIC01NDEsNyArNTMyLDYgQEAKIAkJcmV0ID0ga3ZtX2NhbGxfaHlwKF9fa3ZtX3ZjcHVfcnVuLCB2Y3B1KTsKIAogCQl2Y3B1LT5tb2RlID0gT1VUU0lERV9HVUVTVF9NT0RFOwotCQl2Y3B1LT5hcmNoLmxhc3RfcGNwdSA9IHNtcF9wcm9jZXNzb3JfaWQoKTsKIAkJa3ZtX2d1ZXN0X2V4aXQoKTsKIAkJdHJhY2Vfa3ZtX2V4aXQoKnZjcHVfcGModmNwdSkpOwogCQkvKgpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0va3ZtL2NvcHJvYy5jIGIvYXJjaC9hcm0va3ZtL2NvcHJvYy5jCmluZGV4IDc5MjhkYmQuLmYzZDg4ZGMgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2t2bS9jb3Byb2MuYworKysgYi9hcmNoL2FybS9rdm0vY29wcm9jLmMKQEAgLTE4OSw4MiArMTg5LDQwIEBACiAJcmV0dXJuIHRydWU7CiB9CiAKLS8qIFNlZSBub3RlIGF0IEFSTSBBUk0gQjEuMTQuNCAqLworLyoKKyAqIFNlZSBub3RlIGF0IEFSTXY3IEFSTSBCMS4xNC40IChUTDtEUjogUy9XIG9wcyBhcmUgbm90IGVhc2lseSB2aXJ0dWFsaXplZCkuCisgKi8KIHN0YXRpYyBib29sIGFjY2Vzc19kY3N3KHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwKIAkJCWNvbnN0IHN0cnVjdCBjb3Byb2NfcGFyYW1zICpwLAogCQkJY29uc3Qgc3RydWN0IGNvcHJvY19yZWcgKnIpCiB7Ci0JdW5zaWduZWQgbG9uZyB2YWw7Ci0JaW50IGNwdTsKLQogCWlmICghcC0+aXNfd3JpdGUpCiAJCXJldHVybiByZWFkX2Zyb21fd3JpdGVfb25seSh2Y3B1LCBwKTsKIAotCWNwdSA9IGdldF9jcHUoKTsKLQotCWNwdW1hc2tfc2V0YWxsKCZ2Y3B1LT5hcmNoLnJlcXVpcmVfZGNhY2hlX2ZsdXNoKTsKLQljcHVtYXNrX2NsZWFyX2NwdShjcHUsICZ2Y3B1LT5hcmNoLnJlcXVpcmVfZGNhY2hlX2ZsdXNoKTsKLQotCS8qIElmIHdlIHdlcmUgYWxyZWFkeSBwcmVlbXB0ZWQsIHRha2UgdGhlIGxvbmcgd2F5IGFyb3VuZCAqLwotCWlmIChjcHUgIT0gdmNwdS0+YXJjaC5sYXN0X3BjcHUpIHsKLQkJZmx1c2hfY2FjaGVfYWxsKCk7Ci0JCWdvdG8gZG9uZTsKLQl9Ci0KLQl2YWwgPSAqdmNwdV9yZWcodmNwdSwgcC0+UnQxKTsKLQotCXN3aXRjaCAocC0+Q1JtKSB7Ci0JY2FzZSA2OgkJCS8qIFVwZ3JhZGUgRENJU1cgdG8gRENDSVNXLCBhcyBwZXIgSENSLlNXSU8gKi8KLQljYXNlIDE0OgkJLyogRENDSVNXICovCi0JCWFzbSB2b2xhdGlsZSgibWNyIHAxNSwgMCwgJTAsIGM3LCBjMTQsIDIiIDogOiAiciIgKHZhbCkpOwotCQlicmVhazsKLQotCWNhc2UgMTA6CQkvKiBEQ0NTVyAqLwotCQlhc20gdm9sYXRpbGUoIm1jciBwMTUsIDAsICUwLCBjNywgYzEwLCAyIiA6IDogInIiICh2YWwpKTsKLQkJYnJlYWs7Ci0JfQotCi1kb25lOgotCXB1dF9jcHUoKTsKLQorCWt2bV9zZXRfd2F5X2ZsdXNoKHZjcHUpOwogCXJldHVybiB0cnVlOwogfQogCiAvKgogICogR2VuZXJpYyBhY2Nlc3NvciBmb3IgVk0gcmVnaXN0ZXJzLiBPbmx5IGNhbGxlZCBhcyBsb25nIGFzIEhDUl9UVk0KLSAqIGlzIHNldC4KKyAqIGlzIHNldC4gIElmIHRoZSBndWVzdCBlbmFibGVzIHRoZSBNTVUsIHdlIHN0b3AgdHJhcHBpbmcgdGhlIFZNCisgKiBzeXNfcmVncyBhbmQgbGVhdmUgaXQgaW4gY29tcGxldGUgY29udHJvbCBvZiB0aGUgY2FjaGVzLgorICoKKyAqIFVzZWQgYnkgdGhlIGNwdS1zcGVjaWZpYyBjb2RlLgogICovCi1zdGF0aWMgYm9vbCBhY2Nlc3Nfdm1fcmVnKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwKLQkJCSAgY29uc3Qgc3RydWN0IGNvcHJvY19wYXJhbXMgKnAsCi0JCQkgIGNvbnN0IHN0cnVjdCBjb3Byb2NfcmVnICpyKQorYm9vbCBhY2Nlc3Nfdm1fcmVnKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwKKwkJICAgY29uc3Qgc3RydWN0IGNvcHJvY19wYXJhbXMgKnAsCisJCSAgIGNvbnN0IHN0cnVjdCBjb3Byb2NfcmVnICpyKQogeworCWJvb2wgd2FzX2VuYWJsZWQgPSB2Y3B1X2hhc19jYWNoZV9lbmFibGVkKHZjcHUpOworCiAJQlVHX09OKCFwLT5pc193cml0ZSk7CiAKIAl2Y3B1LT5hcmNoLmNwMTVbci0+cmVnXSA9ICp2Y3B1X3JlZyh2Y3B1LCBwLT5SdDEpOwogCWlmIChwLT5pc182NGJpdCkKIAkJdmNwdS0+YXJjaC5jcDE1W3ItPnJlZyArIDFdID0gKnZjcHVfcmVnKHZjcHUsIHAtPlJ0Mik7CiAKLQlyZXR1cm4gdHJ1ZTsKLX0KLQotLyoKLSAqIFNDVExSIGFjY2Vzc29yLiBPbmx5IGNhbGxlZCBhcyBsb25nIGFzIEhDUl9UVk0gaXMgc2V0LiAgSWYgdGhlCi0gKiBndWVzdCBlbmFibGVzIHRoZSBNTVUsIHdlIHN0b3AgdHJhcHBpbmcgdGhlIFZNIHN5c19yZWdzIGFuZCBsZWF2ZQotICogaXQgaW4gY29tcGxldGUgY29udHJvbCBvZiB0aGUgY2FjaGVzLgotICoKLSAqIFVzZWQgYnkgdGhlIGNwdS1zcGVjaWZpYyBjb2RlLgotICovCi1ib29sIGFjY2Vzc19zY3RscihzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUsCi0JCSAgY29uc3Qgc3RydWN0IGNvcHJvY19wYXJhbXMgKnAsCi0JCSAgY29uc3Qgc3RydWN0IGNvcHJvY19yZWcgKnIpCi17Ci0JYWNjZXNzX3ZtX3JlZyh2Y3B1LCBwLCByKTsKLQotCWlmICh2Y3B1X2hhc19jYWNoZV9lbmFibGVkKHZjcHUpKSB7CS8qIE1NVStDYWNoZXMgZW5hYmxlZD8gKi8KLQkJdmNwdS0+YXJjaC5oY3IgJj0gfkhDUl9UVk07Ci0JCXN0YWdlMl9mbHVzaF92bSh2Y3B1LT5rdm0pOwotCX0KLQorCWt2bV90b2dnbGVfY2FjaGUodmNwdSwgd2FzX2VuYWJsZWQpOwogCXJldHVybiB0cnVlOwogfQogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9rdm0vY29wcm9jLmggYi9hcmNoL2FybS9rdm0vY29wcm9jLmgKaW5kZXggMWE0NGJiZS4uODhkMjRhMyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0va3ZtL2NvcHJvYy5oCisrKyBiL2FyY2gvYXJtL2t2bS9jb3Byb2MuaApAQCAtMTUzLDggKzE1Myw4IEBACiAjZGVmaW5lIGlzNjQJCS5pc182NCA9IHRydWUKICNkZWZpbmUgaXMzMgkJLmlzXzY0ID0gZmFsc2UKIAotYm9vbCBhY2Nlc3Nfc2N0bHIoc3RydWN0IGt2bV92Y3B1ICp2Y3B1LAotCQkgIGNvbnN0IHN0cnVjdCBjb3Byb2NfcGFyYW1zICpwLAotCQkgIGNvbnN0IHN0cnVjdCBjb3Byb2NfcmVnICpyKTsKK2Jvb2wgYWNjZXNzX3ZtX3JlZyhzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUsCisJCSAgIGNvbnN0IHN0cnVjdCBjb3Byb2NfcGFyYW1zICpwLAorCQkgICBjb25zdCBzdHJ1Y3QgY29wcm9jX3JlZyAqcik7CiAKICNlbmRpZiAvKiBfX0FSTV9LVk1fQ09QUk9DX0xPQ0FMX0hfXyAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0va3ZtL2NvcHJvY19hMTUuYyBiL2FyY2gvYXJtL2t2bS9jb3Byb2NfYTE1LmMKaW5kZXggZTZmNGFlNC4uYTcxMzY3NSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0va3ZtL2NvcHJvY19hMTUuYworKysgYi9hcmNoL2FybS9rdm0vY29wcm9jX2ExNS5jCkBAIC0zNCw3ICszNCw3IEBACiBzdGF0aWMgY29uc3Qgc3RydWN0IGNvcHJvY19yZWcgYTE1X3JlZ3NbXSA9IHsKIAkvKiBTQ1RMUjogc3dhcHBlZCBieSBpbnRlcnJ1cHQuUy4gKi8KIAl7IENSbiggMSksIENSbSggMCksIE9wMSggMCksIE9wMiggMCksIGlzMzIsCi0JCQlhY2Nlc3Nfc2N0bHIsIHJlc2V0X3ZhbCwgYzFfU0NUTFIsIDB4MDBDNTAwNzggfSwKKwkJCWFjY2Vzc192bV9yZWcsIHJlc2V0X3ZhbCwgYzFfU0NUTFIsIDB4MDBDNTAwNzggfSwKIH07CiAKIHN0YXRpYyBzdHJ1Y3Qga3ZtX2NvcHJvY190YXJnZXRfdGFibGUgYTE1X3RhcmdldF90YWJsZSA9IHsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2t2bS9jb3Byb2NfYTcuYyBiL2FyY2gvYXJtL2t2bS9jb3Byb2NfYTcuYwppbmRleCAxN2ZjN2NkLi5iMTllNDZkIDEwMDY0NAotLS0gYS9hcmNoL2FybS9rdm0vY29wcm9jX2E3LmMKKysrIGIvYXJjaC9hcm0va3ZtL2NvcHJvY19hNy5jCkBAIC0zNyw3ICszNyw3IEBACiBzdGF0aWMgY29uc3Qgc3RydWN0IGNvcHJvY19yZWcgYTdfcmVnc1tdID0gewogCS8qIFNDVExSOiBzd2FwcGVkIGJ5IGludGVycnVwdC5TLiAqLwogCXsgQ1JuKCAxKSwgQ1JtKCAwKSwgT3AxKCAwKSwgT3AyKCAwKSwgaXMzMiwKLQkJCWFjY2Vzc19zY3RsciwgcmVzZXRfdmFsLCBjMV9TQ1RMUiwgMHgwMEM1MDg3OCB9LAorCQkJYWNjZXNzX3ZtX3JlZywgcmVzZXRfdmFsLCBjMV9TQ1RMUiwgMHgwMEM1MDg3OCB9LAogfTsKIAogc3RhdGljIHN0cnVjdCBrdm1fY29wcm9jX3RhcmdldF90YWJsZSBhN190YXJnZXRfdGFibGUgPSB7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9rdm0vbW11LmMgYi9hcmNoL2FybS9rdm0vbW11LmMKaW5kZXggMWRjOTc3OC4uMTM2NjYyNSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0va3ZtL21tdS5jCisrKyBiL2FyY2gvYXJtL2t2bS9tbXUuYwpAQCAtNTgsNiArNTgsMjYgQEAKIAkJa3ZtX2NhbGxfaHlwKF9fa3ZtX3RsYl9mbHVzaF92bWlkX2lwYSwga3ZtLCBpcGEpOwogfQogCisvKgorICogRC1DYWNoZSBtYW5hZ2VtZW50IGZ1bmN0aW9ucy4gVGhleSB0YWtlIHRoZSBwYWdlIHRhYmxlIGVudHJpZXMgYnkKKyAqIHZhbHVlLCBhcyB0aGV5IGFyZSBmbHVzaGluZyB0aGUgY2FjaGUgdXNpbmcgdGhlIGtlcm5lbCBtYXBwaW5nIChvcgorICoga21hcCBvbiAzMmJpdCkuCisgKi8KK3N0YXRpYyB2b2lkIGt2bV9mbHVzaF9kY2FjaGVfcHRlKHB0ZV90IHB0ZSkKK3sKKwlfX2t2bV9mbHVzaF9kY2FjaGVfcHRlKHB0ZSk7Cit9CisKK3N0YXRpYyB2b2lkIGt2bV9mbHVzaF9kY2FjaGVfcG1kKHBtZF90IHBtZCkKK3sKKwlfX2t2bV9mbHVzaF9kY2FjaGVfcG1kKHBtZCk7Cit9CisKK3N0YXRpYyB2b2lkIGt2bV9mbHVzaF9kY2FjaGVfcHVkKHB1ZF90IHB1ZCkKK3sKKwlfX2t2bV9mbHVzaF9kY2FjaGVfcHVkKHB1ZCk7Cit9CisKIHN0YXRpYyBpbnQgbW11X3RvcHVwX21lbW9yeV9jYWNoZShzdHJ1Y3Qga3ZtX21tdV9tZW1vcnlfY2FjaGUgKmNhY2hlLAogCQkJCSAgaW50IG1pbiwgaW50IG1heCkKIHsKQEAgLTExOSw2ICsxMzksMjYgQEAKIAlwdXRfcGFnZSh2aXJ0X3RvX3BhZ2UocG1kKSk7CiB9CiAKKy8qCisgKiBVbm1hcHBpbmcgdnMgZGNhY2hlIG1hbmFnZW1lbnQ6CisgKgorICogSWYgYSBndWVzdCBtYXBzIGNlcnRhaW4gbWVtb3J5IHBhZ2VzIGFzIHVuY2FjaGVkLCBhbGwgd3JpdGVzIHdpbGwKKyAqIGJ5cGFzcyB0aGUgZGF0YSBjYWNoZSBhbmQgZ28gZGlyZWN0bHkgdG8gUkFNLiAgSG93ZXZlciwgdGhlIENQVXMKKyAqIGNhbiBzdGlsbCBzcGVjdWxhdGUgcmVhZHMgKG5vdCB3cml0ZXMpIGFuZCBmaWxsIGNhY2hlIGxpbmVzIHdpdGgKKyAqIGRhdGEuCisgKgorICogVGhvc2UgY2FjaGUgbGluZXMgd2lsbCBiZSAqY2xlYW4qIGNhY2hlIGxpbmVzIHRob3VnaCwgc28gYQorICogY2xlYW4raW52YWxpZGF0ZSBvcGVyYXRpb24gaXMgZXF1aXZhbGVudCB0byBhbiBpbnZhbGlkYXRlCisgKiBvcGVyYXRpb24sIGJlY2F1c2Ugbm8gY2FjaGUgbGluZXMgYXJlIG1hcmtlZCBkaXJ0eS4KKyAqCisgKiBUaG9zZSBjbGVhbiBjYWNoZSBsaW5lcyBjb3VsZCBiZSBmaWxsZWQgcHJpb3IgdG8gYW4gdW5jYWNoZWQgd3JpdGUKKyAqIGJ5IHRoZSBndWVzdCwgYW5kIHRoZSBjYWNoZSBjb2hlcmVudCBJTyBzdWJzeXN0ZW0gd291bGQgdGhlcmVmb3JlCisgKiBlbmQgdXAgd3JpdGluZyBvbGQgZGF0YSB0byBkaXNrLgorICoKKyAqIFRoaXMgaXMgd2h5IHJpZ2h0IGFmdGVyIHVubWFwcGluZyBhIHBhZ2Uvc2VjdGlvbiBhbmQgaW52YWxpZGF0aW5nCisgKiB0aGUgY29ycmVzcG9uZGluZyBUTEJzLCB3ZSBjYWxsIGt2bV9mbHVzaF9kY2FjaGVfcCooKSB0byBtYWtlIHN1cmUKKyAqIHRoZSBJTyBzdWJzeXN0ZW0gd2lsbCBuZXZlciBoaXQgaW4gdGhlIGNhY2hlLgorICovCiBzdGF0aWMgdm9pZCB1bm1hcF9wdGVzKHN0cnVjdCBrdm0gKmt2bSwgcG1kX3QgKnBtZCwKIAkJICAgICAgIHBoeXNfYWRkcl90IGFkZHIsIHBoeXNfYWRkcl90IGVuZCkKIHsKQEAgLTEyOCw5ICsxNjgsMTYgQEAKIAlzdGFydF9wdGUgPSBwdGUgPSBwdGVfb2Zmc2V0X2tlcm5lbChwbWQsIGFkZHIpOwogCWRvIHsKIAkJaWYgKCFwdGVfbm9uZSgqcHRlKSkgeworCQkJcHRlX3Qgb2xkX3B0ZSA9ICpwdGU7CisKIAkJCWt2bV9zZXRfcHRlKHB0ZSwgX19wdGUoMCkpOwotCQkJcHV0X3BhZ2UodmlydF90b19wYWdlKHB0ZSkpOwogCQkJa3ZtX3RsYl9mbHVzaF92bWlkX2lwYShrdm0sIGFkZHIpOworCisJCQkvKiBObyBuZWVkIHRvIGludmFsaWRhdGUgdGhlIGNhY2hlIGZvciBkZXZpY2UgbWFwcGluZ3MgKi8KKwkJCWlmICgocHRlX3ZhbChvbGRfcHRlKSAmIFBBR0VfUzJfREVWSUNFKSAhPSBQQUdFX1MyX0RFVklDRSkKKwkJCQlrdm1fZmx1c2hfZGNhY2hlX3B0ZShvbGRfcHRlKTsKKworCQkJcHV0X3BhZ2UodmlydF90b19wYWdlKHB0ZSkpOwogCQl9CiAJfSB3aGlsZSAocHRlKyssIGFkZHIgKz0gUEFHRV9TSVpFLCBhZGRyICE9IGVuZCk7CiAKQEAgLTE0OSw4ICsxOTYsMTMgQEAKIAkJbmV4dCA9IGt2bV9wbWRfYWRkcl9lbmQoYWRkciwgZW5kKTsKIAkJaWYgKCFwbWRfbm9uZSgqcG1kKSkgewogCQkJaWYgKGt2bV9wbWRfaHVnZSgqcG1kKSkgeworCQkJCXBtZF90IG9sZF9wbWQgPSAqcG1kOworCiAJCQkJcG1kX2NsZWFyKHBtZCk7CiAJCQkJa3ZtX3RsYl9mbHVzaF92bWlkX2lwYShrdm0sIGFkZHIpOworCisJCQkJa3ZtX2ZsdXNoX2RjYWNoZV9wbWQob2xkX3BtZCk7CisKIAkJCQlwdXRfcGFnZSh2aXJ0X3RvX3BhZ2UocG1kKSk7CiAJCQl9IGVsc2UgewogCQkJCXVubWFwX3B0ZXMoa3ZtLCBwbWQsIGFkZHIsIG5leHQpOwpAQCAtMTczLDggKzIyNSwxMyBAQAogCQluZXh0ID0ga3ZtX3B1ZF9hZGRyX2VuZChhZGRyLCBlbmQpOwogCQlpZiAoIXB1ZF9ub25lKCpwdWQpKSB7CiAJCQlpZiAocHVkX2h1Z2UoKnB1ZCkpIHsKKwkJCQlwdWRfdCBvbGRfcHVkID0gKnB1ZDsKKwogCQkJCXB1ZF9jbGVhcihwdWQpOwogCQkJCWt2bV90bGJfZmx1c2hfdm1pZF9pcGEoa3ZtLCBhZGRyKTsKKworCQkJCWt2bV9mbHVzaF9kY2FjaGVfcHVkKG9sZF9wdWQpOworCiAJCQkJcHV0X3BhZ2UodmlydF90b19wYWdlKHB1ZCkpOwogCQkJfSBlbHNlIHsKIAkJCQl1bm1hcF9wbWRzKGt2bSwgcHVkLCBhZGRyLCBuZXh0KTsKQEAgLTIwOSwxMCArMjY2LDkgQEAKIAogCXB0ZSA9IHB0ZV9vZmZzZXRfa2VybmVsKHBtZCwgYWRkcik7CiAJZG8gewotCQlpZiAoIXB0ZV9ub25lKCpwdGUpKSB7Ci0JCQlodmFfdCBodmEgPSBnZm5fdG9faHZhKGt2bSwgYWRkciA+PiBQQUdFX1NISUZUKTsKLQkJCWt2bV9mbHVzaF9kY2FjaGVfdG9fcG9jKCh2b2lkKilodmEsIFBBR0VfU0laRSk7Ci0JCX0KKwkJaWYgKCFwdGVfbm9uZSgqcHRlKSAmJgorCQkgICAgKHB0ZV92YWwoKnB0ZSkgJiBQQUdFX1MyX0RFVklDRSkgIT0gUEFHRV9TMl9ERVZJQ0UpCisJCQlrdm1fZmx1c2hfZGNhY2hlX3B0ZSgqcHRlKTsKIAl9IHdoaWxlIChwdGUrKywgYWRkciArPSBQQUdFX1NJWkUsIGFkZHIgIT0gZW5kKTsKIH0KIApAQCAtMjI2LDEyICsyODIsMTAgQEAKIAlkbyB7CiAJCW5leHQgPSBrdm1fcG1kX2FkZHJfZW5kKGFkZHIsIGVuZCk7CiAJCWlmICghcG1kX25vbmUoKnBtZCkpIHsKLQkJCWlmIChrdm1fcG1kX2h1Z2UoKnBtZCkpIHsKLQkJCQlodmFfdCBodmEgPSBnZm5fdG9faHZhKGt2bSwgYWRkciA+PiBQQUdFX1NISUZUKTsKLQkJCQlrdm1fZmx1c2hfZGNhY2hlX3RvX3BvYygodm9pZCopaHZhLCBQTURfU0laRSk7Ci0JCQl9IGVsc2UgeworCQkJaWYgKGt2bV9wbWRfaHVnZSgqcG1kKSkKKwkJCQlrdm1fZmx1c2hfZGNhY2hlX3BtZCgqcG1kKTsKKwkJCWVsc2UKIAkJCQlzdGFnZTJfZmx1c2hfcHRlcyhrdm0sIHBtZCwgYWRkciwgbmV4dCk7Ci0JCQl9CiAJCX0KIAl9IHdoaWxlIChwbWQrKywgYWRkciA9IG5leHQsIGFkZHIgIT0gZW5kKTsKIH0KQEAgLTI0NiwxMiArMzAwLDEwIEBACiAJZG8gewogCQluZXh0ID0ga3ZtX3B1ZF9hZGRyX2VuZChhZGRyLCBlbmQpOwogCQlpZiAoIXB1ZF9ub25lKCpwdWQpKSB7Ci0JCQlpZiAocHVkX2h1Z2UoKnB1ZCkpIHsKLQkJCQlodmFfdCBodmEgPSBnZm5fdG9faHZhKGt2bSwgYWRkciA+PiBQQUdFX1NISUZUKTsKLQkJCQlrdm1fZmx1c2hfZGNhY2hlX3RvX3BvYygodm9pZCopaHZhLCBQVURfU0laRSk7Ci0JCQl9IGVsc2UgeworCQkJaWYgKHB1ZF9odWdlKCpwdWQpKQorCQkJCWt2bV9mbHVzaF9kY2FjaGVfcHVkKCpwdWQpOworCQkJZWxzZQogCQkJCXN0YWdlMl9mbHVzaF9wbWRzKGt2bSwgcHVkLCBhZGRyLCBuZXh0KTsKLQkJCX0KIAkJfQogCX0gd2hpbGUgKHB1ZCsrLCBhZGRyID0gbmV4dCwgYWRkciAhPSBlbmQpOwogfQpAQCAtMjc4LDcgKzMzMCw3IEBACiAgKiBHbyB0aHJvdWdoIHRoZSBzdGFnZSAyIHBhZ2UgdGFibGVzIGFuZCBpbnZhbGlkYXRlIGFueSBjYWNoZSBsaW5lcwogICogYmFja2luZyBtZW1vcnkgYWxyZWFkeSBtYXBwZWQgdG8gdGhlIFZNLgogICovCi12b2lkIHN0YWdlMl9mbHVzaF92bShzdHJ1Y3Qga3ZtICprdm0pCitzdGF0aWMgdm9pZCBzdGFnZTJfZmx1c2hfdm0oc3RydWN0IGt2bSAqa3ZtKQogewogCXN0cnVjdCBrdm1fbWVtc2xvdHMgKnNsb3RzOwogCXN0cnVjdCBrdm1fbWVtb3J5X3Nsb3QgKm1lbXNsb3Q7CkBAIC05MDUsNiArOTU3LDEyIEBACiAJcmV0dXJuICFwZm5fdmFsaWQocGZuKTsKIH0KIAorc3RhdGljIHZvaWQgY29oZXJlbnRfY2FjaGVfZ3Vlc3RfcGFnZShzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUsIHBmbl90IHBmbiwKKwkJCQkgICAgICB1bnNpZ25lZCBsb25nIHNpemUsIGJvb2wgdW5jYWNoZWQpCit7CisJX19jb2hlcmVudF9jYWNoZV9ndWVzdF9wYWdlKHZjcHUsIHBmbiwgc2l6ZSwgdW5jYWNoZWQpOworfQorCiBzdGF0aWMgaW50IHVzZXJfbWVtX2Fib3J0KHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwgcGh5c19hZGRyX3QgZmF1bHRfaXBhLAogCQkJICBzdHJ1Y3Qga3ZtX21lbW9yeV9zbG90ICptZW1zbG90LCB1bnNpZ25lZCBsb25nIGh2YSwKIAkJCSAgdW5zaWduZWQgbG9uZyBmYXVsdF9zdGF0dXMpCkBAIC05OTQsOCArMTA1Miw3IEBACiAJCQlrdm1fc2V0X3MycG1kX3dyaXRhYmxlKCZuZXdfcG1kKTsKIAkJCWt2bV9zZXRfcGZuX2RpcnR5KHBmbik7CiAJCX0KLQkJY29oZXJlbnRfY2FjaGVfZ3Vlc3RfcGFnZSh2Y3B1LCBodmEgJiBQTURfTUFTSywgUE1EX1NJWkUsCi0JCQkJCSAgZmF1bHRfaXBhX3VuY2FjaGVkKTsKKwkJY29oZXJlbnRfY2FjaGVfZ3Vlc3RfcGFnZSh2Y3B1LCBwZm4sIFBNRF9TSVpFLCBmYXVsdF9pcGFfdW5jYWNoZWQpOwogCQlyZXQgPSBzdGFnZTJfc2V0X3BtZF9odWdlKGt2bSwgbWVtY2FjaGUsIGZhdWx0X2lwYSwgJm5ld19wbWQpOwogCX0gZWxzZSB7CiAJCXB0ZV90IG5ld19wdGUgPSBwZm5fcHRlKHBmbiwgbWVtX3R5cGUpOwpAQCAtMTAwMyw4ICsxMDYwLDcgQEAKIAkJCWt2bV9zZXRfczJwdGVfd3JpdGFibGUoJm5ld19wdGUpOwogCQkJa3ZtX3NldF9wZm5fZGlydHkocGZuKTsKIAkJfQotCQljb2hlcmVudF9jYWNoZV9ndWVzdF9wYWdlKHZjcHUsIGh2YSwgUEFHRV9TSVpFLAotCQkJCQkgIGZhdWx0X2lwYV91bmNhY2hlZCk7CisJCWNvaGVyZW50X2NhY2hlX2d1ZXN0X3BhZ2UodmNwdSwgcGZuLCBQQUdFX1NJWkUsIGZhdWx0X2lwYV91bmNhY2hlZCk7CiAJCXJldCA9IHN0YWdlMl9zZXRfcHRlKGt2bSwgbWVtY2FjaGUsIGZhdWx0X2lwYSwgJm5ld19wdGUsCiAJCQlwZ3Byb3RfdmFsKG1lbV90eXBlKSA9PSBwZ3Byb3RfdmFsKFBBR0VfUzJfREVWSUNFKSk7CiAJfQpAQCAtMTQxMSwzICsxNDY3LDcxIEBACiAJdW5tYXBfc3RhZ2UyX3JhbmdlKGt2bSwgZ3BhLCBzaXplKTsKIAlzcGluX3VubG9jaygma3ZtLT5tbXVfbG9jayk7CiB9CisKKy8qCisgKiBTZWUgbm90ZSBhdCBBUk12NyBBUk0gQjEuMTQuNCAoVEw7RFI6IFMvVyBvcHMgYXJlIG5vdCBlYXNpbHkgdmlydHVhbGl6ZWQpLgorICoKKyAqIE1haW4gcHJvYmxlbXM6CisgKiAtIFMvVyBvcHMgYXJlIGxvY2FsIHRvIGEgQ1BVIChub3QgYnJvYWRjYXN0KQorICogLSBXZSBoYXZlIGxpbmUgbWlncmF0aW9uIGJlaGluZCBvdXIgYmFjayAoc3BlY3VsYXRpb24pCisgKiAtIFN5c3RlbSBjYWNoZXMgZG9uJ3Qgc3VwcG9ydCBTL1cgYXQgYWxsIChkYW1uISkKKyAqCisgKiBJbiB0aGUgZmFjZSBvZiB0aGUgYWJvdmUsIHRoZSBiZXN0IHdlIGNhbiBkbyBpcyB0byB0cnkgYW5kIGNvbnZlcnQKKyAqIFMvVyBvcHMgdG8gVkEgb3BzLiBCZWNhdXNlIHRoZSBndWVzdCBpcyBub3QgYWxsb3dlZCB0byBpbmZlciB0aGUKKyAqIFMvVyB0byBQQSBtYXBwaW5nLCBpdCBjYW4gb25seSB1c2UgUy9XIHRvIG51a2UgdGhlIHdob2xlIGNhY2hlLAorICogd2hpY2ggaXMgYSByYXRoZXIgZ29vZCB0aGluZyBmb3IgdXMuCisgKgorICogQWxzbywgaXQgaXMgb25seSB1c2VkIHdoZW4gdHVybmluZyBjYWNoZXMgb24vb2ZmICgiVGhlIGV4cGVjdGVkCisgKiB1c2FnZSBvZiB0aGUgY2FjaGUgbWFpbnRlbmFuY2UgaW5zdHJ1Y3Rpb25zIHRoYXQgb3BlcmF0ZSBieSBzZXQvd2F5CisgKiBpcyBhc3NvY2lhdGVkIHdpdGggdGhlIGNhY2hlIG1haW50ZW5hbmNlIGluc3RydWN0aW9ucyBhc3NvY2lhdGVkCisgKiB3aXRoIHRoZSBwb3dlcmRvd24gYW5kIHBvd2VydXAgb2YgY2FjaGVzLCBpZiB0aGlzIGlzIHJlcXVpcmVkIGJ5CisgKiB0aGUgaW1wbGVtZW50YXRpb24uIikuCisgKgorICogV2UgdXNlIHRoZSBmb2xsb3dpbmcgcG9saWN5OgorICoKKyAqIC0gSWYgd2UgdHJhcCBhIFMvVyBvcGVyYXRpb24sIHdlIGVuYWJsZSBWTSB0cmFwcGluZyB0byBkZXRlY3QKKyAqICAgY2FjaGVzIGJlaW5nIHR1cm5lZCBvbi9vZmYsIGFuZCBkbyBhIGZ1bGwgY2xlYW4uCisgKgorICogLSBXZSBmbHVzaCB0aGUgY2FjaGVzIG9uIGJvdGggY2FjaGVzIGJlaW5nIHR1cm5lZCBvbiBhbmQgb2ZmLgorICoKKyAqIC0gT25jZSB0aGUgY2FjaGVzIGFyZSBlbmFibGVkLCB3ZSBzdG9wIHRyYXBwaW5nIFZNIG9wcy4KKyAqLwordm9pZCBrdm1fc2V0X3dheV9mbHVzaChzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpCit7CisJdW5zaWduZWQgbG9uZyBoY3IgPSB2Y3B1X2dldF9oY3IodmNwdSk7CisKKwkvKgorCSAqIElmIHRoaXMgaXMgdGhlIGZpcnN0IHRpbWUgd2UgZG8gYSBTL1cgb3BlcmF0aW9uCisJICogKGkuZS4gSENSX1RWTSBub3Qgc2V0KSBmbHVzaCB0aGUgd2hvbGUgbWVtb3J5LCBhbmQgc2V0IHRoZQorCSAqIFZNIHRyYXBwaW5nLgorCSAqCisJICogT3RoZXJ3aXNlLCByZWx5IG9uIHRoZSBWTSB0cmFwcGluZyB0byB3YWl0IGZvciB0aGUgTU1VICsKKwkgKiBDYWNoZXMgdG8gYmUgdHVybmVkIG9mZi4gQXQgdGhhdCBwb2ludCwgd2UnbGwgYmUgYWJsZSB0bworCSAqIGNsZWFuIHRoZSBjYWNoZXMgYWdhaW4uCisJICovCisJaWYgKCEoaGNyICYgSENSX1RWTSkpIHsKKwkJdHJhY2Vfa3ZtX3NldF93YXlfZmx1c2goKnZjcHVfcGModmNwdSksCisJCQkJCXZjcHVfaGFzX2NhY2hlX2VuYWJsZWQodmNwdSkpOworCQlzdGFnZTJfZmx1c2hfdm0odmNwdS0+a3ZtKTsKKwkJdmNwdV9zZXRfaGNyKHZjcHUsIGhjciB8IEhDUl9UVk0pOworCX0KK30KKwordm9pZCBrdm1fdG9nZ2xlX2NhY2hlKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwgYm9vbCB3YXNfZW5hYmxlZCkKK3sKKwlib29sIG5vd19lbmFibGVkID0gdmNwdV9oYXNfY2FjaGVfZW5hYmxlZCh2Y3B1KTsKKworCS8qCisJICogSWYgc3dpdGNoaW5nIHRoZSBNTVUrY2FjaGVzIG9uLCBuZWVkIHRvIGludmFsaWRhdGUgdGhlIGNhY2hlcy4KKwkgKiBJZiBzd2l0Y2hpbmcgaXQgb2ZmLCBuZWVkIHRvIGNsZWFuIHRoZSBjYWNoZXMuCisJICogQ2xlYW4gKyBpbnZhbGlkYXRlIGRvZXMgdGhlIHRyaWNrIGFsd2F5cy4KKwkgKi8KKwlpZiAobm93X2VuYWJsZWQgIT0gd2FzX2VuYWJsZWQpCisJCXN0YWdlMl9mbHVzaF92bSh2Y3B1LT5rdm0pOworCisJLyogQ2FjaGVzIGFyZSBub3cgb24sIHN0b3AgdHJhcHBpbmcgVk0gb3BzICh1bnRpbCBhIFMvVyBvcCkgKi8KKwlpZiAobm93X2VuYWJsZWQpCisJCXZjcHVfc2V0X2hjcih2Y3B1LCB2Y3B1X2dldF9oY3IodmNwdSkgJiB+SENSX1RWTSk7CisKKwl0cmFjZV9rdm1fdG9nZ2xlX2NhY2hlKCp2Y3B1X3BjKHZjcHUpLCB3YXNfZW5hYmxlZCwgbm93X2VuYWJsZWQpOworfQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0va3ZtL3RyYWNlLmggYi9hcmNoL2FybS9rdm0vdHJhY2UuaAppbmRleCBiMWQ2NDBmLi5iNmE2ZTcxIDEwMDY0NAotLS0gYS9hcmNoL2FybS9rdm0vdHJhY2UuaAorKysgYi9hcmNoL2FybS9rdm0vdHJhY2UuaApAQCAtMjIzLDYgKzIyMyw0NSBAQAogCQkgIF9fZW50cnktPnZjcHVfcGMsIF9fZW50cnktPnIwLCBfX2VudHJ5LT5pbW0pCiApOwogCitUUkFDRV9FVkVOVChrdm1fc2V0X3dheV9mbHVzaCwKKwkgICAgVFBfUFJPVE8odW5zaWduZWQgbG9uZyB2Y3B1X3BjLCBib29sIGNhY2hlKSwKKwkgICAgVFBfQVJHUyh2Y3B1X3BjLCBjYWNoZSksCisKKwkgICAgVFBfU1RSVUNUX19lbnRyeSgKKwkJICAgIF9fZmllbGQoCXVuc2lnbmVkIGxvbmcsCXZjcHVfcGMJCSkKKwkJICAgIF9fZmllbGQoCWJvb2wsCQljYWNoZQkJKQorCSAgICApLAorCisJICAgIFRQX2Zhc3RfYXNzaWduKAorCQkgICAgX19lbnRyeS0+dmNwdV9wYwkJPSB2Y3B1X3BjOworCQkgICAgX19lbnRyeS0+Y2FjaGUJCT0gY2FjaGU7CisJICAgICksCisKKwkgICAgVFBfcHJpbnRrKCJTL1cgZmx1c2ggYXQgMHglMDE2bHggKGNhY2hlICVzKSIsCisJCSAgICAgIF9fZW50cnktPnZjcHVfcGMsIF9fZW50cnktPmNhY2hlID8gIm9uIiA6ICJvZmYiKQorKTsKKworVFJBQ0VfRVZFTlQoa3ZtX3RvZ2dsZV9jYWNoZSwKKwkgICAgVFBfUFJPVE8odW5zaWduZWQgbG9uZyB2Y3B1X3BjLCBib29sIHdhcywgYm9vbCBub3cpLAorCSAgICBUUF9BUkdTKHZjcHVfcGMsIHdhcywgbm93KSwKKworCSAgICBUUF9TVFJVQ1RfX2VudHJ5KAorCQkgICAgX19maWVsZCgJdW5zaWduZWQgbG9uZywJdmNwdV9wYwkJKQorCQkgICAgX19maWVsZCgJYm9vbCwJCXdhcwkJKQorCQkgICAgX19maWVsZCgJYm9vbCwJCW5vdwkJKQorCSAgICApLAorCisJICAgIFRQX2Zhc3RfYXNzaWduKAorCQkgICAgX19lbnRyeS0+dmNwdV9wYwkJPSB2Y3B1X3BjOworCQkgICAgX19lbnRyeS0+d2FzCQk9IHdhczsKKwkJICAgIF9fZW50cnktPm5vdwkJPSBub3c7CisJICAgICksCisKKwkgICAgVFBfcHJpbnRrKCJWTSBvcCBhdCAweCUwMTZseCAoY2FjaGUgd2FzICVzLCBub3cgJXMpIiwKKwkJICAgICAgX19lbnRyeS0+dmNwdV9wYywgX19lbnRyeS0+d2FzID8gIm9uIiA6ICJvZmYiLAorCQkgICAgICBfX2VudHJ5LT5ub3cgPyAib24iIDogIm9mZiIpCispOworCiAjZW5kaWYgLyogX1RSQUNFX0tWTV9IICovCiAKICN1bmRlZiBUUkFDRV9JTkNMVURFX1BBVEgKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtbXZlYnUvY29oZXJlbmN5LmMgYi9hcmNoL2FybS9tYWNoLW12ZWJ1L2NvaGVyZW5jeS5jCmluZGV4IDM1ODVjYjMuLmNjZWY4ODAgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtbXZlYnUvY29oZXJlbmN5LmMKKysrIGIvYXJjaC9hcm0vbWFjaC1tdmVidS9jb2hlcmVuY3kuYwpAQCAtMTkwLDYgKzE5MCwxMyBAQAogCWFyY2hfaW9yZW1hcF9jYWxsZXIgPSBhcm1hZGFfcGNpZV93YV9pb3JlbWFwX2NhbGxlcjsKIAogCS8qCisJICogV2Ugc2hvdWxkIHN3aXRjaCB0aGUgUEwzMTAgdG8gSS9PIGNvaGVyZW5jeSBtb2RlIG9ubHkgaWYKKwkgKiBJL08gY29oZXJlbmN5IGlzIGFjdHVhbGx5IGVuYWJsZWQuCisJICovCisJaWYgKCFjb2hlcmVuY3lfYXZhaWxhYmxlKCkpCisJCXJldHVybjsKKworCS8qCiAJICogQWRkIHRoZSBQTDMxMCBwcm9wZXJ0eSAiYXJtLGlvLWNvaGVyZW50Ii4gVGhpcyBtYWtlcyBzdXJlIHRoZQogCSAqIG91dGVyIHN5bmMgb3BlcmF0aW9uIGlzIG5vdCB1c2VkLCB3aGljaCBhbGxvd3MgdG8KIAkgKiB3b3JrYXJvdW5kIHRoZSBzeXN0ZW0gZXJyYXR1bSB0aGF0IGNhdXNlcyBkZWFkbG9ja3Mgd2hlbgpAQCAtMjQ2LDkgKzI1MywxNCBAQAogCXJldHVybiB0eXBlOwogfQogCisvKgorICogQXMgYSBwcmVjYXV0aW9uLCB3ZSBjdXJyZW50bHkgY29tcGxldGVseSBkaXNhYmxlIGhhcmR3YXJlIEkvTworICogY29oZXJlbmN5LCB1bnRpbCBlbm91Z2ggdGVzdGluZyBpcyBkb25lIHdpdGggYXV0b21hdGljIEkvTworICogc3luY2hyb25pemF0aW9uIGJhcnJpZXJzIHRvIHZhbGlkYXRlIHRoYXQgaXQgaXMgYSBwcm9wZXIgc29sdXRpb24uCisgKi8KIGludCBjb2hlcmVuY3lfYXZhaWxhYmxlKHZvaWQpCiB7Ci0JcmV0dXJuIGNvaGVyZW5jeV90eXBlKCkgIT0gQ09IRVJFTkNZX0ZBQlJJQ19UWVBFX05PTkU7CisJcmV0dXJuIGZhbHNlOwogfQogCiBpbnQgX19pbml0IGNvaGVyZW5jeV9pbml0KHZvaWQpCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW9tYXAyL2NvbW1vbi5oIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9jb21tb24uaAppbmRleCBkYjU3NzQxLi42NGU0NGQ2IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL2NvbW1vbi5oCisrKyBiL2FyY2gvYXJtL21hY2gtb21hcDIvY29tbW9uLmgKQEAgLTIxMSw2ICsyMTEsNyBAQAogZXh0ZXJuIHN0cnVjdCBkZXZpY2UgKm9tYXAyX2dldF9sM19kZXZpY2Uodm9pZCk7CiBleHRlcm4gc3RydWN0IGRldmljZSAqb21hcDRfZ2V0X2RzcF9kZXZpY2Uodm9pZCk7CiAKK3Vuc2lnbmVkIGludCBvbWFwNF94bGF0ZV9pcnEodW5zaWduZWQgaW50IGh3aXJxKTsKIHZvaWQgb21hcF9naWNfb2ZfaW5pdCh2b2lkKTsKIAogI2lmZGVmIENPTkZJR19DQUNIRV9MMlgwCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW9tYXAyL29tYXA0LWNvbW1vbi5jIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9vbWFwNC1jb21tb24uYwppbmRleCBiN2NiNDRhLi5jYzMwZTQ5IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL29tYXA0LWNvbW1vbi5jCisrKyBiL2FyY2gvYXJtL21hY2gtb21hcDIvb21hcDQtY29tbW9uLmMKQEAgLTI1Niw2ICsyNTYsMzggQEAKIH0KIG9tYXBfZWFybHlfaW5pdGNhbGwob21hcDRfc2FyX3JhbV9pbml0KTsKIAorc3RhdGljIHN0cnVjdCBvZl9kZXZpY2VfaWQgZ2ljX21hdGNoW10gPSB7CisJeyAuY29tcGF0aWJsZSA9ICJhcm0sY29ydGV4LWE5LWdpYyIsIH0sCisJeyAuY29tcGF0aWJsZSA9ICJhcm0sY29ydGV4LWExNS1naWMiLCB9LAorCXsgfSwKK307CisKK3N0YXRpYyBzdHJ1Y3QgZGV2aWNlX25vZGUgKmdpY19ub2RlOworCit1bnNpZ25lZCBpbnQgb21hcDRfeGxhdGVfaXJxKHVuc2lnbmVkIGludCBod2lycSkKK3sKKwlzdHJ1Y3Qgb2ZfcGhhbmRsZV9hcmdzIGlycV9kYXRhOworCXVuc2lnbmVkIGludCBpcnE7CisKKwlpZiAoIWdpY19ub2RlKQorCQlnaWNfbm9kZSA9IG9mX2ZpbmRfbWF0Y2hpbmdfbm9kZShOVUxMLCBnaWNfbWF0Y2gpOworCisJaWYgKFdBUk5fT04oIWdpY19ub2RlKSkKKwkJcmV0dXJuIGh3aXJxOworCisJaXJxX2RhdGEubnAgPSBnaWNfbm9kZTsKKwlpcnFfZGF0YS5hcmdzX2NvdW50ID0gMzsKKwlpcnFfZGF0YS5hcmdzWzBdID0gMDsKKwlpcnFfZGF0YS5hcmdzWzFdID0gaHdpcnEgLSBPTUFQNDRYWF9JUlFfR0lDX1NUQVJUOworCWlycV9kYXRhLmFyZ3NbMl0gPSBJUlFfVFlQRV9MRVZFTF9ISUdIOworCisJaXJxID0gaXJxX2NyZWF0ZV9vZl9tYXBwaW5nKCZpcnFfZGF0YSk7CisJaWYgKFdBUk5fT04oIWlycSkpCisJCWlycSA9IGh3aXJxOworCisJcmV0dXJuIGlycTsKK30KKwogdm9pZCBfX2luaXQgb21hcF9naWNfb2ZfaW5pdCh2b2lkKQogewogCXN0cnVjdCBkZXZpY2Vfbm9kZSAqbnA7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW9tYXAyL29tYXBfaHdtb2QuYyBiL2FyY2gvYXJtL21hY2gtb21hcDIvb21hcF9od21vZC5jCmluZGV4IGNiYjkwOGQuLjkwMjVmZmYgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb21hcDIvb21hcF9od21vZC5jCisrKyBiL2FyY2gvYXJtL21hY2gtb21hcDIvb21hcF9od21vZC5jCkBAIC0zNTM0LDkgKzM1MzQsMTUgQEAKIAogCW1wdV9pcnFzX2NudCA9IF9jb3VudF9tcHVfaXJxcyhvaCk7CiAJZm9yIChpID0gMDsgaSA8IG1wdV9pcnFzX2NudDsgaSsrKSB7CisJCXVuc2lnbmVkIGludCBpcnE7CisKKwkJaWYgKG9oLT54bGF0ZV9pcnEpCisJCQlpcnEgPSBvaC0+eGxhdGVfaXJxKChvaC0+bXB1X2lycXMgKyBpKS0+aXJxKTsKKwkJZWxzZQorCQkJaXJxID0gKG9oLT5tcHVfaXJxcyArIGkpLT5pcnE7CiAJCShyZXMgKyByKS0+bmFtZSA9IChvaC0+bXB1X2lycXMgKyBpKS0+bmFtZTsKLQkJKHJlcyArIHIpLT5zdGFydCA9IChvaC0+bXB1X2lycXMgKyBpKS0+aXJxOwotCQkocmVzICsgciktPmVuZCA9IChvaC0+bXB1X2lycXMgKyBpKS0+aXJxOworCQkocmVzICsgciktPnN0YXJ0ID0gaXJxOworCQkocmVzICsgciktPmVuZCA9IGlycTsKIAkJKHJlcyArIHIpLT5mbGFncyA9IElPUkVTT1VSQ0VfSVJROwogCQlyKys7CiAJfQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9vbWFwX2h3bW9kLmggYi9hcmNoL2FybS9tYWNoLW9tYXAyL29tYXBfaHdtb2QuaAppbmRleCAzNWNhNmVmLi41YjQyZmFmIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL29tYXBfaHdtb2QuaAorKysgYi9hcmNoL2FybS9tYWNoLW9tYXAyL29tYXBfaHdtb2QuaApAQCAtNjc2LDYgKzY3Niw3IEBACiAJc3BpbmxvY2tfdAkJCV9sb2NrOwogCXN0cnVjdCBsaXN0X2hlYWQJCW5vZGU7CiAJc3RydWN0IG9tYXBfaHdtb2Rfb2NwX2lmCSpfbXB1X3BvcnQ7CisJdW5zaWduZWQgaW50CQkJKCp4bGF0ZV9pcnEpKHVuc2lnbmVkIGludCk7CiAJdTE2CQkJCWZsYWdzOwogCXU4CQkJCW1wdV9ydF9pZHg7CiAJdTgJCQkJcmVzcG9uc2VfbGF0OwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9vbWFwX2h3bW9kXzQ0eHhfZGF0YS5jIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9vbWFwX2h3bW9kXzQ0eHhfZGF0YS5jCmluZGV4IGMzMTRiM2MuLmY1ZTY4YTcgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb21hcDIvb21hcF9od21vZF80NHh4X2RhdGEuYworKysgYi9hcmNoL2FybS9tYWNoLW9tYXAyL29tYXBfaHdtb2RfNDR4eF9kYXRhLmMKQEAgLTQ3OSw2ICs0NzksNyBAQAogCS5jbGFzcwkJPSAmb21hcDQ0eHhfZG1hX2h3bW9kX2NsYXNzLAogCS5jbGtkbV9uYW1lCT0gImwzX2RtYV9jbGtkbSIsCiAJLm1wdV9pcnFzCT0gb21hcDQ0eHhfZG1hX3N5c3RlbV9pcnFzLAorCS54bGF0ZV9pcnEJPSBvbWFwNF94bGF0ZV9pcnEsCiAJLm1haW5fY2xrCT0gImwzX2Rpdl9jayIsCiAJLnByY20gPSB7CiAJCS5vbWFwNCA9IHsKQEAgLTY0MCw2ICs2NDEsNyBAQAogCS5jbGFzcwkJPSAmb21hcDQ0eHhfZGlzcGNfaHdtb2RfY2xhc3MsCiAJLmNsa2RtX25hbWUJPSAibDNfZHNzX2Nsa2RtIiwKIAkubXB1X2lycXMJPSBvbWFwNDR4eF9kc3NfZGlzcGNfaXJxcywKKwkueGxhdGVfaXJxCT0gb21hcDRfeGxhdGVfaXJxLAogCS5zZG1hX3JlcXMJPSBvbWFwNDR4eF9kc3NfZGlzcGNfc2RtYV9yZXFzLAogCS5tYWluX2Nsawk9ICJkc3NfZHNzX2NsayIsCiAJLnByY20gPSB7CkBAIC02OTMsNiArNjk1LDcgQEAKIAkuY2xhc3MJCT0gJm9tYXA0NHh4X2RzaV9od21vZF9jbGFzcywKIAkuY2xrZG1fbmFtZQk9ICJsM19kc3NfY2xrZG0iLAogCS5tcHVfaXJxcwk9IG9tYXA0NHh4X2Rzc19kc2kxX2lycXMsCisJLnhsYXRlX2lycQk9IG9tYXA0X3hsYXRlX2lycSwKIAkuc2RtYV9yZXFzCT0gb21hcDQ0eHhfZHNzX2RzaTFfc2RtYV9yZXFzLAogCS5tYWluX2Nsawk9ICJkc3NfZHNzX2NsayIsCiAJLnByY20gPSB7CkBAIC03MjYsNiArNzI5LDcgQEAKIAkuY2xhc3MJCT0gJm9tYXA0NHh4X2RzaV9od21vZF9jbGFzcywKIAkuY2xrZG1fbmFtZQk9ICJsM19kc3NfY2xrZG0iLAogCS5tcHVfaXJxcwk9IG9tYXA0NHh4X2Rzc19kc2kyX2lycXMsCisJLnhsYXRlX2lycQk9IG9tYXA0X3hsYXRlX2lycSwKIAkuc2RtYV9yZXFzCT0gb21hcDQ0eHhfZHNzX2RzaTJfc2RtYV9yZXFzLAogCS5tYWluX2Nsawk9ICJkc3NfZHNzX2NsayIsCiAJLnByY20gPSB7CkBAIC03ODQsNiArNzg4LDcgQEAKIAkgKi8KIAkuZmxhZ3MJCT0gSFdNT0RfU1dTVVBfU0lETEUsCiAJLm1wdV9pcnFzCT0gb21hcDQ0eHhfZHNzX2hkbWlfaXJxcywKKwkueGxhdGVfaXJxCT0gb21hcDRfeGxhdGVfaXJxLAogCS5zZG1hX3JlcXMJPSBvbWFwNDR4eF9kc3NfaGRtaV9zZG1hX3JlcXMsCiAJLm1haW5fY2xrCT0gImRzc180OG1oel9jbGsiLAogCS5wcmNtID0gewpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9vbWFwX2h3bW9kXzU0eHhfZGF0YS5jIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9vbWFwX2h3bW9kXzU0eHhfZGF0YS5jCmluZGV4IDNlOTUyMzAuLjdjM2ZhYzAgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb21hcDIvb21hcF9od21vZF81NHh4X2RhdGEuYworKysgYi9hcmNoL2FybS9tYWNoLW9tYXAyL29tYXBfaHdtb2RfNTR4eF9kYXRhLmMKQEAgLTI4OCw2ICsyODgsNyBAQAogCS5jbGFzcwkJPSAmb21hcDU0eHhfZG1hX2h3bW9kX2NsYXNzLAogCS5jbGtkbV9uYW1lCT0gImRtYV9jbGtkbSIsCiAJLm1wdV9pcnFzCT0gb21hcDU0eHhfZG1hX3N5c3RlbV9pcnFzLAorCS54bGF0ZV9pcnEJPSBvbWFwNF94bGF0ZV9pcnEsCiAJLm1haW5fY2xrCT0gImwzX2ljbGtfZGl2IiwKIAkucHJjbSA9IHsKIAkJLm9tYXA0ID0gewpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9wcmNtLWNvbW1vbi5oIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9wcmNtLWNvbW1vbi5oCmluZGV4IGE4ZTRiNTguLjYxNjNkNjYgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb21hcDIvcHJjbS1jb21tb24uaAorKysgYi9hcmNoL2FybS9tYWNoLW9tYXAyL3ByY20tY29tbW9uLmgKQEAgLTQ5OCw2ICs0OTgsNyBAQAogCXU4IG5yX2lycXM7CiAJY29uc3Qgc3RydWN0IG9tYXBfcHJjbV9pcnEgKmlycXM7CiAJaW50IGlycTsKKwl1bnNpZ25lZCBpbnQgKCp4bGF0ZV9pcnEpKHVuc2lnbmVkIGludCk7CiAJdm9pZCAoKnJlYWRfcGVuZGluZ19pcnFzKSh1bnNpZ25lZCBsb25nICpldmVudHMpOwogCXZvaWQgKCpvY3BfYmFycmllcikodm9pZCk7CiAJdm9pZCAoKnNhdmVfYW5kX2NsZWFyX2lycWVuKSh1MzIgKnNhdmVkX21hc2spOwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9wcm00NHh4LmMgYi9hcmNoL2FybS9tYWNoLW9tYXAyL3BybTQ0eHguYwppbmRleCBjYzE3MGZiLi40MDhjNjRlIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL3BybTQ0eHguYworKysgYi9hcmNoL2FybS9tYWNoLW9tYXAyL3BybTQ0eHguYwpAQCAtNDksNiArNDksNyBAQAogCS5pcnFzCQkJPSBvbWFwNF9wcmNtX2lycXMsCiAJLm5yX2lycXMJCT0gQVJSQVlfU0laRShvbWFwNF9wcmNtX2lycXMpLAogCS5pcnEJCQk9IDExICsgT01BUDQ0WFhfSVJRX0dJQ19TVEFSVCwKKwkueGxhdGVfaXJxCQk9IG9tYXA0X3hsYXRlX2lycSwKIAkucmVhZF9wZW5kaW5nX2lycXMJPSAmb21hcDQ0eHhfcHJtX3JlYWRfcGVuZGluZ19pcnFzLAogCS5vY3BfYmFycmllcgkJPSAmb21hcDQ0eHhfcHJtX29jcF9iYXJyaWVyLAogCS5zYXZlX2FuZF9jbGVhcl9pcnFlbgk9ICZvbWFwNDR4eF9wcm1fc2F2ZV9hbmRfY2xlYXJfaXJxZW4sCkBAIC03NTEsOCArNzUyLDEwIEBACiAJCX0KIAogCQkvKiBPbmNlIE9NQVA0IERUIGlzIGZpbGxlZCBhcyB3ZWxsICovCi0JCWlmIChpcnFfbnVtID49IDApCisJCWlmIChpcnFfbnVtID49IDApIHsKIAkJCW9tYXA0X3ByY21faXJxX3NldHVwLmlycSA9IGlycV9udW07CisJCQlvbWFwNF9wcmNtX2lycV9zZXR1cC54bGF0ZV9pcnEgPSBOVUxMOworCQl9CiAJfQogCiAJb21hcDQ0eHhfcHJtX2VuYWJsZV9pb193YWtldXAoKTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb21hcDIvcHJtX2NvbW1vbi5jIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9wcm1fY29tbW9uLmMKaW5kZXggNzc5OTQwYy4uZGVhMjgzMyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9wcm1fY29tbW9uLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9wcm1fY29tbW9uLmMKQEAgLTE4Nyw2ICsxODcsNyBAQAogICovCiB2b2lkIG9tYXBfcHJjbV9pcnFfY2xlYW51cCh2b2lkKQogeworCXVuc2lnbmVkIGludCBpcnE7CiAJaW50IGk7CiAKIAlpZiAoIXByY21faXJxX3NldHVwKSB7CkBAIC0yMTEsNyArMjEyLDExIEBACiAJa2ZyZWUocHJjbV9pcnFfc2V0dXAtPnByaW9yaXR5X21hc2spOwogCXByY21faXJxX3NldHVwLT5wcmlvcml0eV9tYXNrID0gTlVMTDsKIAotCWlycV9zZXRfY2hhaW5lZF9oYW5kbGVyKHByY21faXJxX3NldHVwLT5pcnEsIE5VTEwpOworCWlmIChwcmNtX2lycV9zZXR1cC0+eGxhdGVfaXJxKQorCQlpcnEgPSBwcmNtX2lycV9zZXR1cC0+eGxhdGVfaXJxKHByY21faXJxX3NldHVwLT5pcnEpOworCWVsc2UKKwkJaXJxID0gcHJjbV9pcnFfc2V0dXAtPmlycTsKKwlpcnFfc2V0X2NoYWluZWRfaGFuZGxlcihpcnEsIE5VTEwpOwogCiAJaWYgKHByY21faXJxX3NldHVwLT5iYXNlX2lycSA+IDApCiAJCWlycV9mcmVlX2Rlc2NzKHByY21faXJxX3NldHVwLT5iYXNlX2lycSwKQEAgLTI1OSw2ICsyNjQsNyBAQAogCWludCBvZmZzZXQsIGk7CiAJc3RydWN0IGlycV9jaGlwX2dlbmVyaWMgKmdjOwogCXN0cnVjdCBpcnFfY2hpcF90eXBlICpjdDsKKwl1bnNpZ25lZCBpbnQgaXJxOwogCiAJaWYgKCFpcnFfc2V0dXApCiAJCXJldHVybiAtRUlOVkFMOwpAQCAtMjk4LDcgKzMwNCwxMSBAQAogCQkJCTEgPDwgKG9mZnNldCAmIDB4MWYpOwogCX0KIAotCWlycV9zZXRfY2hhaW5lZF9oYW5kbGVyKGlycV9zZXR1cC0+aXJxLCBvbWFwX3ByY21faXJxX2hhbmRsZXIpOworCWlmIChpcnFfc2V0dXAtPnhsYXRlX2lycSkKKwkJaXJxID0gaXJxX3NldHVwLT54bGF0ZV9pcnEoaXJxX3NldHVwLT5pcnEpOworCWVsc2UKKwkJaXJxID0gaXJxX3NldHVwLT5pcnE7CisJaXJxX3NldF9jaGFpbmVkX2hhbmRsZXIoaXJxLCBvbWFwX3ByY21faXJxX2hhbmRsZXIpOwogCiAJaXJxX3NldHVwLT5iYXNlX2lycSA9IGlycV9hbGxvY19kZXNjcygtMSwgMCwgaXJxX3NldHVwLT5ucl9yZWdzICogMzIsCiAJCTApOwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vbWFwMi90d2wtY29tbW9uLmMgYi9hcmNoL2FybS9tYWNoLW9tYXAyL3R3bC1jb21tb24uYwppbmRleCA0NDU3ZTczLi4yOTJlY2EwIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL3R3bC1jb21tb24uYworKysgYi9hcmNoL2FybS9tYWNoLW9tYXAyL3R3bC1jb21tb24uYwpAQCAtNjYsMTkgKzY2LDI0IEBACiAJb21hcF9yZWdpc3Rlcl9pMmNfYnVzKGJ1cywgY2xrcmF0ZSwgJnBtaWNfaTJjX2JvYXJkX2luZm8sIDEpOwogfQogCisjaWZkZWYgQ09ORklHX0FSQ0hfT01BUDQKIHZvaWQgX19pbml0IG9tYXA0X3BtaWNfaW5pdChjb25zdCBjaGFyICpwbWljX3R5cGUsCiAJCSAgICBzdHJ1Y3QgdHdsNDAzMF9wbGF0Zm9ybV9kYXRhICpwbWljX2RhdGEsCiAJCSAgICBzdHJ1Y3QgaTJjX2JvYXJkX2luZm8gKmRldmljZXMsIGludCBucl9kZXZpY2VzKQogewogCS8qIFBNSUMgcGFydCovCisJdW5zaWduZWQgaW50IGlycTsKKwogCW9tYXBfbXV4X2luaXRfc2lnbmFsKCJzeXNfbmlycTEiLCBPTUFQX1BJTl9JTlBVVF9QVUxMVVAgfCBPTUFQX1BJTl9PRkZfV0FLRVVQRU5BQkxFKTsKIAlvbWFwX211eF9pbml0X3NpZ25hbCgiZnJlZl9jbGswX291dC5zeXNfZHJtX21zZWN1cmUiLCBPTUFQX1BJTl9PVVRQVVQpOwotCW9tYXBfcG1pY19pbml0KDEsIDQwMCwgcG1pY190eXBlLCA3ICsgT01BUDQ0WFhfSVJRX0dJQ19TVEFSVCwgcG1pY19kYXRhKTsKKwlpcnEgPSBvbWFwNF94bGF0ZV9pcnEoNyArIE9NQVA0NFhYX0lSUV9HSUNfU1RBUlQpOworCW9tYXBfcG1pY19pbml0KDEsIDQwMCwgcG1pY190eXBlLCBpcnEsIHBtaWNfZGF0YSk7CiAKIAkvKiBSZWdpc3RlciBhZGRpdGlvbmFsIGRldmljZXMgb24gaTJjMSBidXMgaWYgbmVlZGVkICovCiAJaWYgKGRldmljZXMpCiAJCWkyY19yZWdpc3Rlcl9ib2FyZF9pbmZvKDEsIGRldmljZXMsIG5yX2RldmljZXMpOwogfQorI2VuZGlmCiAKIHZvaWQgX19pbml0IG9tYXBfcG1pY19sYXRlX2luaXQodm9pZCkKIHsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtc2htb2JpbGUvYm9hcmQtYXBlNmV2bS5jIGIvYXJjaC9hcm0vbWFjaC1zaG1vYmlsZS9ib2FyZC1hcGU2ZXZtLmMKaW5kZXggNjZmNjc4MS4uNDQ0ZjIyZCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zaG1vYmlsZS9ib2FyZC1hcGU2ZXZtLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1zaG1vYmlsZS9ib2FyZC1hcGU2ZXZtLmMKQEAgLTE4LDYgKzE4LDggQEAKICNpbmNsdWRlIDxsaW51eC9ncGlvX2tleXMuaD4KICNpbmNsdWRlIDxsaW51eC9pbnB1dC5oPgogI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgorI2luY2x1ZGUgPGxpbnV4L2lycWNoaXAuaD4KKyNpbmNsdWRlIDxsaW51eC9pcnFjaGlwL2FybS1naWMuaD4KICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KICNpbmNsdWRlIDxsaW51eC9tZmQvdG1pby5oPgogI2luY2x1ZGUgPGxpbnV4L21tYy9ob3N0Lmg+CkBAIC0yNzMsNiArMjc1LDIyIEBACiAJCQkJICAgICAgc2l6ZW9mKGFwZTZldm1fbGVkc19wZGF0YSkpOwogfQogCitzdGF0aWMgdm9pZCBfX2luaXQgYXBlNmV2bV9sZWdhY3lfaW5pdF90aW1lKHZvaWQpCit7CisJLyogRG8gbm90IGludm9rZSBEVC1iYXNlZCB0aW1lcnMgdmlhIGNsb2Nrc291cmNlX29mX2luaXQoKSAqLworfQorCitzdGF0aWMgdm9pZCBfX2luaXQgYXBlNmV2bV9sZWdhY3lfaW5pdF9pcnEodm9pZCkKK3sKKwl2b2lkIF9faW9tZW0gKmdpY19kaXN0X2Jhc2UgPSBpb3JlbWFwX25vY2FjaGUoMHhmMTAwMTAwMCwgMHgxMDAwKTsKKwl2b2lkIF9faW9tZW0gKmdpY19jcHVfYmFzZSA9IGlvcmVtYXBfbm9jYWNoZSgweGYxMDAyMDAwLCAweDEwMDApOworCisJZ2ljX2luaXQoMCwgMjksIGdpY19kaXN0X2Jhc2UsIGdpY19jcHVfYmFzZSk7CisKKwkvKiBEbyBub3QgaW52b2tlIERULWJhc2VkIGludGVycnVwdCBjb2RlIHZpYSBpcnFjaGlwX2luaXQoKSAqLworfQorCisKIHN0YXRpYyBjb25zdCBjaGFyICphcGU2ZXZtX2JvYXJkc19jb21wYXRfZHRbXSBfX2luaXRkYXRhID0gewogCSJyZW5lc2FzLGFwZTZldm0iLAogCU5VTEwsCkBAIC0yODAsNyArMjk4LDkgQEAKIAogRFRfTUFDSElORV9TVEFSVChBUEU2RVZNX0RULCAiYXBlNmV2bSIpCiAJLmluaXRfZWFybHkJPSBzaG1vYmlsZV9pbml0X2RlbGF5LAorCS5pbml0X2lycSAgICAgICA9IGFwZTZldm1fbGVnYWN5X2luaXRfaXJxLAogCS5pbml0X21hY2hpbmUJPSBhcGU2ZXZtX2FkZF9zdGFuZGFyZF9kZXZpY2VzLAogCS5pbml0X2xhdGUJPSBzaG1vYmlsZV9pbml0X2xhdGUsCiAJLmR0X2NvbXBhdAk9IGFwZTZldm1fYm9hcmRzX2NvbXBhdF9kdCwKKwkuaW5pdF90aW1lCT0gYXBlNmV2bV9sZWdhY3lfaW5pdF90aW1lLAogTUFDSElORV9FTkQKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtc2htb2JpbGUvYm9hcmQtbGFnZXIuYyBiL2FyY2gvYXJtL21hY2gtc2htb2JpbGUvYm9hcmQtbGFnZXIuYwppbmRleCBmODE5N2ViLi42NWIxMjhkIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXNobW9iaWxlL2JvYXJkLWxhZ2VyLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1zaG1vYmlsZS9ib2FyZC1sYWdlci5jCkBAIC0yMSw2ICsyMSw4IEBACiAjaW5jbHVkZSA8bGludXgvaW5wdXQuaD4KICNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KICNpbmNsdWRlIDxsaW51eC9pcnEuaD4KKyNpbmNsdWRlIDxsaW51eC9pcnFjaGlwLmg+CisjaW5jbHVkZSA8bGludXgvaXJxY2hpcC9hcm0tZ2ljLmg+CiAjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CiAjaW5jbHVkZSA8bGludXgvbGVkcy5oPgogI2luY2x1ZGUgPGxpbnV4L21mZC90bWlvLmg+CkBAIC04MTEsNiArODEzLDE2IEBACiAJCQkJCSAgbGFnZXJfa3N6ODA0MV9maXh1cCk7CiB9CiAKK3N0YXRpYyB2b2lkIF9faW5pdCBsYWdlcl9sZWdhY3lfaW5pdF9pcnEodm9pZCkKK3sKKwl2b2lkIF9faW9tZW0gKmdpY19kaXN0X2Jhc2UgPSBpb3JlbWFwX25vY2FjaGUoMHhmMTAwMTAwMCwgMHgxMDAwKTsKKwl2b2lkIF9faW9tZW0gKmdpY19jcHVfYmFzZSA9IGlvcmVtYXBfbm9jYWNoZSgweGYxMDAyMDAwLCAweDEwMDApOworCisJZ2ljX2luaXQoMCwgMjksIGdpY19kaXN0X2Jhc2UsIGdpY19jcHVfYmFzZSk7CisKKwkvKiBEbyBub3QgaW52b2tlIERULWJhc2VkIGludGVycnVwdCBjb2RlIHZpYSBpcnFjaGlwX2luaXQoKSAqLworfQorCiBzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGxhZ2VyX2JvYXJkc19jb21wYXRfZHRbXSBfX2luaXRjb25zdCA9IHsKIAkicmVuZXNhcyxsYWdlciIsCiAJTlVMTCwKQEAgLTgxOSw2ICs4MzEsNyBAQAogRFRfTUFDSElORV9TVEFSVChMQUdFUl9EVCwgImxhZ2VyIikKIAkuc21wCQk9IHNtcF9vcHMocjhhNzc5MF9zbXBfb3BzKSwKIAkuaW5pdF9lYXJseQk9IHNobW9iaWxlX2luaXRfZGVsYXksCisJLmluaXRfaXJxCT0gbGFnZXJfbGVnYWN5X2luaXRfaXJxLAogCS5pbml0X3RpbWUJPSByY2FyX2dlbjJfdGltZXJfaW5pdCwKIAkuaW5pdF9tYWNoaW5lCT0gbGFnZXJfaW5pdCwKIAkuaW5pdF9sYXRlCT0gc2htb2JpbGVfaW5pdF9sYXRlLApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zaG1vYmlsZS9zZXR1cC1yOGE3Nzc4LmMgYi9hcmNoL2FybS9tYWNoLXNobW9iaWxlL3NldHVwLXI4YTc3NzguYwppbmRleCAxNzBiZDE0Li5jZWY4ODk1IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXNobW9iaWxlL3NldHVwLXI4YTc3NzguYworKysgYi9hcmNoL2FybS9tYWNoLXNobW9iaWxlL3NldHVwLXI4YTc3NzguYwpAQCAtNTc2LDExICs1NzYsMTggQEAKIHZvaWQgX19pbml0IHI4YTc3NzhfaW5pdF9pcnFfZHQodm9pZCkKIHsKIAl2b2lkIF9faW9tZW0gKmJhc2UgPSBpb3JlbWFwX25vY2FjaGUoMHhmZTcwMDAwMCwgMHgwMDEwMDAwMCk7CisjaWZkZWYgQ09ORklHX0FSQ0hfU0hNT0JJTEVfTEVHQUNZCisJdm9pZCBfX2lvbWVtICpnaWNfZGlzdF9iYXNlID0gaW9yZW1hcF9ub2NhY2hlKDB4ZmU0MzgwMDAsIDB4MTAwMCk7CisJdm9pZCBfX2lvbWVtICpnaWNfY3B1X2Jhc2UgPSBpb3JlbWFwX25vY2FjaGUoMHhmZTQzMDAwMCwgMHgxMDAwKTsKKyNlbmRpZgogCiAJQlVHX09OKCFiYXNlKTsKIAorI2lmZGVmIENPTkZJR19BUkNIX1NITU9CSUxFX0xFR0FDWQorCWdpY19pbml0KDAsIDI5LCBnaWNfZGlzdF9iYXNlLCBnaWNfY3B1X2Jhc2UpOworI2Vsc2UKIAlpcnFjaGlwX2luaXQoKTsKLQorI2VuZGlmCiAJLyogcm91dGUgYWxsIGludGVycnVwdHMgdG8gQVJNICovCiAJX19yYXdfd3JpdGVsKDB4NzNmZmZmZmYsIGJhc2UgKyBJTlQyTlRTUjApOwogCV9fcmF3X3dyaXRlbCgweGZmZmZmZmZmLCBiYXNlICsgSU5UMk5UU1IxKTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtc2htb2JpbGUvc2V0dXAtcjhhNzc3OS5jIGIvYXJjaC9hcm0vbWFjaC1zaG1vYmlsZS9zZXR1cC1yOGE3Nzc5LmMKaW5kZXggNjE1NmQxNy4uMjdkY2VhZjkgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtc2htb2JpbGUvc2V0dXAtcjhhNzc3OS5jCisrKyBiL2FyY2gvYXJtL21hY2gtc2htb2JpbGUvc2V0dXAtcjhhNzc3OS5jCkBAIC03MjAsMTAgKzcyMCwxNyBAQAogCiB2b2lkIF9faW5pdCByOGE3Nzc5X2luaXRfaXJxX2R0KHZvaWQpCiB7CisjaWZkZWYgQ09ORklHX0FSQ0hfU0hNT0JJTEVfTEVHQUNZCisJdm9pZCBfX2lvbWVtICpnaWNfZGlzdF9iYXNlID0gaW9yZW1hcF9ub2NhY2hlKDB4ZjAwMDEwMDAsIDB4MTAwMCk7CisJdm9pZCBfX2lvbWVtICpnaWNfY3B1X2Jhc2UgPSBpb3JlbWFwX25vY2FjaGUoMHhmMDAwMDEwMCwgMHgxMDAwKTsKKyNlbmRpZgogCWdpY19hcmNoX2V4dG4uaXJxX3NldF93YWtlID0gcjhhNzc3OV9zZXRfd2FrZTsKIAorI2lmZGVmIENPTkZJR19BUkNIX1NITU9CSUxFX0xFR0FDWQorCWdpY19pbml0KDAsIDI5LCBnaWNfZGlzdF9iYXNlLCBnaWNfY3B1X2Jhc2UpOworI2Vsc2UKIAlpcnFjaGlwX2luaXQoKTsKLQorI2VuZGlmCiAJLyogcm91dGUgYWxsIGludGVycnVwdHMgdG8gQVJNICovCiAJX19yYXdfd3JpdGVsKDB4ZmZmZmZmZmYsIElOVDJOVFNSMCk7CiAJX19yYXdfd3JpdGVsKDB4M2ZmZmZmZmYsIElOVDJOVFNSMSk7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXNobW9iaWxlL3NldHVwLXJjYXItZ2VuMi5jIGIvYXJjaC9hcm0vbWFjaC1zaG1vYmlsZS9zZXR1cC1yY2FyLWdlbjIuYwppbmRleCAzZGQ2ZWRkLi5jYzk0NzBkIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXNobW9iaWxlL3NldHVwLXJjYXItZ2VuMi5jCisrKyBiL2FyY2gvYXJtL21hY2gtc2htb2JpbGUvc2V0dXAtcmNhci1nZW4yLmMKQEAgLTEzMyw3ICsxMzMsOSBAQAogI2lmZGVmIENPTkZJR19DT01NT05fQ0xLCiAJcmNhcl9nZW4yX2Nsb2Nrc19pbml0KG1vZGUpOwogI2VuZGlmCisjaWZkZWYgQ09ORklHX0FSQ0hfU0hNT0JJTEVfTVVMVEkKIAljbG9ja3NvdXJjZV9vZl9pbml0KCk7CisjZW5kaWYKIH0KIAogc3RydWN0IG1lbW9yeV9yZXNlcnZlX2NvbmZpZyB7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXNobW9iaWxlL3RpbWVyLmMgYi9hcmNoL2FybS9tYWNoLXNobW9iaWxlL3RpbWVyLmMKaW5kZXggZjFkMDI3YS4uMGVkZjJhNiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zaG1vYmlsZS90aW1lci5jCisrKyBiL2FyY2gvYXJtL21hY2gtc2htb2JpbGUvdGltZXIuYwpAQCAtNzAsNiArNzAsMTggQEAKIAlpZiAoIW1heF9mcmVxKQogCQlyZXR1cm47CiAKKyNpZmRlZiBDT05GSUdfQVJDSF9TSE1PQklMRV9MRUdBQ1kKKwkvKiBOb24tbXVsdGlwbGF0Zm9ybSByOGE3M2E0IFNvQyBjYW5ub3QgdXNlIGFyY2ggdGltZXIgZHVlCisJICogdG8gR0lDIGJlaW5nIGluaXRpYWxpemVkIGZyb20gQyBhbmQgYXJjaCB0aW1lciB2aWEgRFQgKi8KKwlpZiAob2ZfbWFjaGluZV9pc19jb21wYXRpYmxlKCJyZW5lc2FzLHI4YTczYTQiKSkKKwkJaGFzX2FyY2hfdGltZXIgPSBmYWxzZTsKKworCS8qIE5vbi1tdWx0aXBsYXRmb3JtIHI4YTc3OTAgU29DIGNhbm5vdCB1c2UgYXJjaCB0aW1lciBkdWUKKwkgKiB0byBHSUMgYmVpbmcgaW5pdGlhbGl6ZWQgZnJvbSBDIGFuZCBhcmNoIHRpbWVyIHZpYSBEVCAqLworCWlmIChvZl9tYWNoaW5lX2lzX2NvbXBhdGlibGUoInJlbmVzYXMscjhhNzc5MCIpKQorCQloYXNfYXJjaF90aW1lciA9IGZhbHNlOworI2VuZGlmCisKIAlpZiAoIWhhc19hcmNoX3RpbWVyIHx8ICFJU19FTkFCTEVEKENPTkZJR19BUk1fQVJDSF9USU1FUikpIHsKIAkJaWYgKGlzX2E3X2E4X2E5KQogCQkJc2htb2JpbGVfc2V0dXBfZGVsYXlfaHoobWF4X2ZyZXEsIDEsIDMpOwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbW0vS2NvbmZpZyBiL2FyY2gvYXJtL21tL0tjb25maWcKaW5kZXggMDM4MjNlNy4uYzQzYzcxNCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbW0vS2NvbmZpZworKysgYi9hcmNoL2FybS9tbS9LY29uZmlnCkBAIC0xMDEyLDYgKzEwMTIsNyBAQAogCiBjb25maWcgQVJNX0tFUk5NRU1fUEVSTVMKIAlib29sICJSZXN0cmljdCBrZXJuZWwgbWVtb3J5IHBlcm1pc3Npb25zIgorCWRlcGVuZHMgb24gTU1VCiAJaGVscAogCSAgSWYgdGhpcyBpcyBzZXQsIGtlcm5lbCBtZW1vcnkgb3RoZXIgdGhhbiBrZXJuZWwgdGV4dCAoYW5kIHJvZGF0YSkKIAkgIHdpbGwgYmUgbWFkZSBub24tZXhlY3V0YWJsZS4gVGhlIHRyYWRlb2ZmIGlzIHRoYXQgZWFjaCByZWdpb24gaXMKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21tL2NvbnRleHQuYyBiL2FyY2gvYXJtL21tL2NvbnRleHQuYwppbmRleCA5MTg5MjU2Li44NDU3NjllIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tbS9jb250ZXh0LmMKKysrIGIvYXJjaC9hcm0vbW0vY29udGV4dC5jCkBAIC0xNDQsMjEgKzE0NCwxNyBAQAogCS8qIFVwZGF0ZSB0aGUgbGlzdCBvZiByZXNlcnZlZCBBU0lEcyBhbmQgdGhlIEFTSUQgYml0bWFwLiAqLwogCWJpdG1hcF9jbGVhcihhc2lkX21hcCwgMCwgTlVNX1VTRVJfQVNJRFMpOwogCWZvcl9lYWNoX3Bvc3NpYmxlX2NwdShpKSB7Ci0JCWlmIChpID09IGNwdSkgewotCQkJYXNpZCA9IDA7Ci0JCX0gZWxzZSB7Ci0JCQlhc2lkID0gYXRvbWljNjRfeGNoZygmcGVyX2NwdShhY3RpdmVfYXNpZHMsIGkpLCAwKTsKLQkJCS8qCi0JCQkgKiBJZiB0aGlzIENQVSBoYXMgYWxyZWFkeSBiZWVuIHRocm91Z2ggYQotCQkJICogcm9sbG92ZXIsIGJ1dCBoYXNuJ3QgcnVuIGFub3RoZXIgdGFzayBpbgotCQkJICogdGhlIG1lYW50aW1lLCB3ZSBtdXN0IHByZXNlcnZlIGl0cyByZXNlcnZlZAotCQkJICogQVNJRCwgYXMgdGhpcyBpcyB0aGUgb25seSB0cmFjZSB3ZSBoYXZlIG9mCi0JCQkgKiB0aGUgcHJvY2VzcyBpdCBpcyBzdGlsbCBydW5uaW5nLgotCQkJICovCi0JCQlpZiAoYXNpZCA9PSAwKQotCQkJCWFzaWQgPSBwZXJfY3B1KHJlc2VydmVkX2FzaWRzLCBpKTsKLQkJCV9fc2V0X2JpdChhc2lkICYgfkFTSURfTUFTSywgYXNpZF9tYXApOwotCQl9CisJCWFzaWQgPSBhdG9taWM2NF94Y2hnKCZwZXJfY3B1KGFjdGl2ZV9hc2lkcywgaSksIDApOworCQkvKgorCQkgKiBJZiB0aGlzIENQVSBoYXMgYWxyZWFkeSBiZWVuIHRocm91Z2ggYQorCQkgKiByb2xsb3ZlciwgYnV0IGhhc24ndCBydW4gYW5vdGhlciB0YXNrIGluCisJCSAqIHRoZSBtZWFudGltZSwgd2UgbXVzdCBwcmVzZXJ2ZSBpdHMgcmVzZXJ2ZWQKKwkJICogQVNJRCwgYXMgdGhpcyBpcyB0aGUgb25seSB0cmFjZSB3ZSBoYXZlIG9mCisJCSAqIHRoZSBwcm9jZXNzIGl0IGlzIHN0aWxsIHJ1bm5pbmcuCisJCSAqLworCQlpZiAoYXNpZCA9PSAwKQorCQkJYXNpZCA9IHBlcl9jcHUocmVzZXJ2ZWRfYXNpZHMsIGkpOworCQlfX3NldF9iaXQoYXNpZCAmIH5BU0lEX01BU0ssIGFzaWRfbWFwKTsKIAkJcGVyX2NwdShyZXNlcnZlZF9hc2lkcywgaSkgPSBhc2lkOwogCX0KIApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbW0vZG1hLW1hcHBpbmcuYyBiL2FyY2gvYXJtL21tL2RtYS1tYXBwaW5nLmMKaW5kZXggNzg2NDc5Ny4uOTAzZGJhMCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbW0vZG1hLW1hcHBpbmcuYworKysgYi9hcmNoL2FybS9tbS9kbWEtbWFwcGluZy5jCkBAIC0xOTQwLDE4ICsxOTQwLDggQEAKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKGFybV9pb21tdV9yZWxlYXNlX21hcHBpbmcpOwogCi0vKioKLSAqIGFybV9pb21tdV9hdHRhY2hfZGV2aWNlCi0gKiBAZGV2OiB2YWxpZCBzdHJ1Y3QgZGV2aWNlIHBvaW50ZXIKLSAqIEBtYXBwaW5nOiBpbyBhZGRyZXNzIHNwYWNlIG1hcHBpbmcgc3RydWN0dXJlIChyZXR1cm5lZCBmcm9tCi0gKglhcm1faW9tbXVfY3JlYXRlX21hcHBpbmcpCi0gKgotICogQXR0YWNoZXMgc3BlY2lmaWVkIGlvIGFkZHJlc3Mgc3BhY2UgbWFwcGluZyB0byB0aGUgcHJvdmlkZWQgZGV2aWNlLAotICogTW9yZSB0aGFuIG9uZSBjbGllbnQgbWlnaHQgYmUgYXR0YWNoZWQgdG8gdGhlIHNhbWUgaW8gYWRkcmVzcyBzcGFjZQotICogbWFwcGluZy4KLSAqLwotaW50IGFybV9pb21tdV9hdHRhY2hfZGV2aWNlKHN0cnVjdCBkZXZpY2UgKmRldiwKLQkJCSAgICBzdHJ1Y3QgZG1hX2lvbW11X21hcHBpbmcgKm1hcHBpbmcpCitzdGF0aWMgaW50IF9fYXJtX2lvbW11X2F0dGFjaF9kZXZpY2Uoc3RydWN0IGRldmljZSAqZGV2LAorCQkJCSAgICAgc3RydWN0IGRtYV9pb21tdV9tYXBwaW5nICptYXBwaW5nKQogewogCWludCBlcnI7CiAKQEAgLTE5NjUsMTUgKzE5NTUsMzUgQEAKIAlwcl9kZWJ1ZygiQXR0YWNoZWQgSU9NTVUgY29udHJvbGxlciB0byAlcyBkZXZpY2UuXG4iLCBkZXZfbmFtZShkZXYpKTsKIAlyZXR1cm4gMDsKIH0KLUVYUE9SVF9TWU1CT0xfR1BMKGFybV9pb21tdV9hdHRhY2hfZGV2aWNlKTsKIAogLyoqCi0gKiBhcm1faW9tbXVfZGV0YWNoX2RldmljZQorICogYXJtX2lvbW11X2F0dGFjaF9kZXZpY2UKICAqIEBkZXY6IHZhbGlkIHN0cnVjdCBkZXZpY2UgcG9pbnRlcgorICogQG1hcHBpbmc6IGlvIGFkZHJlc3Mgc3BhY2UgbWFwcGluZyBzdHJ1Y3R1cmUgKHJldHVybmVkIGZyb20KKyAqCWFybV9pb21tdV9jcmVhdGVfbWFwcGluZykKICAqCi0gKiBEZXRhY2hlcyB0aGUgcHJvdmlkZWQgZGV2aWNlIGZyb20gYSBwcmV2aW91c2x5IGF0dGFjaGVkIG1hcC4KKyAqIEF0dGFjaGVzIHNwZWNpZmllZCBpbyBhZGRyZXNzIHNwYWNlIG1hcHBpbmcgdG8gdGhlIHByb3ZpZGVkIGRldmljZS4KKyAqIFRoaXMgcmVwbGFjZXMgdGhlIGRtYSBvcGVyYXRpb25zIChkbWFfbWFwX29wcyBwb2ludGVyKSB3aXRoIHRoZQorICogSU9NTVUgYXdhcmUgdmVyc2lvbi4KKyAqCisgKiBNb3JlIHRoYW4gb25lIGNsaWVudCBtaWdodCBiZSBhdHRhY2hlZCB0byB0aGUgc2FtZSBpbyBhZGRyZXNzIHNwYWNlCisgKiBtYXBwaW5nLgogICovCi12b2lkIGFybV9pb21tdV9kZXRhY2hfZGV2aWNlKHN0cnVjdCBkZXZpY2UgKmRldikKK2ludCBhcm1faW9tbXVfYXR0YWNoX2RldmljZShzdHJ1Y3QgZGV2aWNlICpkZXYsCisJCQkgICAgc3RydWN0IGRtYV9pb21tdV9tYXBwaW5nICptYXBwaW5nKQoreworCWludCBlcnI7CisKKwllcnIgPSBfX2FybV9pb21tdV9hdHRhY2hfZGV2aWNlKGRldiwgbWFwcGluZyk7CisJaWYgKGVycikKKwkJcmV0dXJuIGVycjsKKworCXNldF9kbWFfb3BzKGRldiwgJmlvbW11X29wcyk7CisJcmV0dXJuIDA7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChhcm1faW9tbXVfYXR0YWNoX2RldmljZSk7CisKK3N0YXRpYyB2b2lkIF9fYXJtX2lvbW11X2RldGFjaF9kZXZpY2Uoc3RydWN0IGRldmljZSAqZGV2KQogewogCXN0cnVjdCBkbWFfaW9tbXVfbWFwcGluZyAqbWFwcGluZzsKIApAQCAtMTk4OSw2ICsxOTk5LDE5IEBACiAKIAlwcl9kZWJ1ZygiRGV0YWNoZWQgSU9NTVUgY29udHJvbGxlciBmcm9tICVzIGRldmljZS5cbiIsIGRldl9uYW1lKGRldikpOwogfQorCisvKioKKyAqIGFybV9pb21tdV9kZXRhY2hfZGV2aWNlCisgKiBAZGV2OiB2YWxpZCBzdHJ1Y3QgZGV2aWNlIHBvaW50ZXIKKyAqCisgKiBEZXRhY2hlcyB0aGUgcHJvdmlkZWQgZGV2aWNlIGZyb20gYSBwcmV2aW91c2x5IGF0dGFjaGVkIG1hcC4KKyAqIFRoaXMgdm9pZHMgdGhlIGRtYSBvcGVyYXRpb25zIChkbWFfbWFwX29wcyBwb2ludGVyKQorICovCit2b2lkIGFybV9pb21tdV9kZXRhY2hfZGV2aWNlKHN0cnVjdCBkZXZpY2UgKmRldikKK3sKKwlfX2FybV9pb21tdV9kZXRhY2hfZGV2aWNlKGRldik7CisJc2V0X2RtYV9vcHMoZGV2LCBOVUxMKTsKK30KIEVYUE9SVF9TWU1CT0xfR1BMKGFybV9pb21tdV9kZXRhY2hfZGV2aWNlKTsKIAogc3RhdGljIHN0cnVjdCBkbWFfbWFwX29wcyAqYXJtX2dldF9pb21tdV9kbWFfbWFwX29wcyhib29sIGNvaGVyZW50KQpAQCAtMjAxMSw3ICsyMDM0LDcgQEAKIAkJcmV0dXJuIGZhbHNlOwogCX0KIAotCWlmIChhcm1faW9tbXVfYXR0YWNoX2RldmljZShkZXYsIG1hcHBpbmcpKSB7CisJaWYgKF9fYXJtX2lvbW11X2F0dGFjaF9kZXZpY2UoZGV2LCBtYXBwaW5nKSkgewogCQlwcl93YXJuKCJGYWlsZWQgdG8gYXR0YWNoZWQgZGV2aWNlICVzIHRvIElPTU1VX21hcHBpbmdcbiIsCiAJCQkJZGV2X25hbWUoZGV2KSk7CiAJCWFybV9pb21tdV9yZWxlYXNlX21hcHBpbmcobWFwcGluZyk7CkBAIC0yMDI1LDcgKzIwNDgsMTAgQEAKIHsKIAlzdHJ1Y3QgZG1hX2lvbW11X21hcHBpbmcgKm1hcHBpbmcgPSBkZXYtPmFyY2hkYXRhLm1hcHBpbmc7CiAKLQlhcm1faW9tbXVfZGV0YWNoX2RldmljZShkZXYpOworCWlmICghbWFwcGluZykKKwkJcmV0dXJuOworCisJX19hcm1faW9tbXVfZGV0YWNoX2RldmljZShkZXYpOwogCWFybV9pb21tdV9yZWxlYXNlX21hcHBpbmcobWFwcGluZyk7CiB9CiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtNjQvTWFrZWZpbGUgYi9hcmNoL2FybTY0L01ha2VmaWxlCmluZGV4IDFjNDNjZWMuLjA2NjY4ODggMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtNjQvTWFrZWZpbGUKKysrIGIvYXJjaC9hcm02NC9NYWtlZmlsZQpAQCAtODUsNiArODUsNyBAQAogIyBXZSB1c2UgTVJQUk9QRVJfRklMRVMgYW5kIENMRUFOX0ZJTEVTIG5vdwogYXJjaGNsZWFuOgogCSQoUSkkKE1BS0UpICQoY2xlYW4pPSQoYm9vdCkKKwkkKFEpJChNQUtFKSAkKGNsZWFuKT0kKGJvb3QpL2R0cwogCiBkZWZpbmUgYXJjaGhlbHAKICAgZWNobyAgJyogSW1hZ2UuZ3ogICAgICAtIENvbXByZXNzZWQga2VybmVsIGltYWdlIChhcmNoLyQoQVJDSCkvYm9vdC9JbWFnZS5neiknCmRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2Jvb3QvZHRzL01ha2VmaWxlIGIvYXJjaC9hcm02NC9ib290L2R0cy9NYWtlZmlsZQppbmRleCAzYjhkNDI3Li5jNjJiMGY0IDEwMDY0NAotLS0gYS9hcmNoL2FybTY0L2Jvb3QvZHRzL01ha2VmaWxlCisrKyBiL2FyY2gvYXJtNjQvYm9vdC9kdHMvTWFrZWZpbGUKQEAgLTMsNiArMyw0IEBACiBkdHMtZGlycyArPSBhcm0KIGR0cy1kaXJzICs9IGNhdml1bQogCi1hbHdheXMJCTo9ICQoZHRiLXkpCiBzdWJkaXIteQk6PSAkKGR0cy1kaXJzKQotY2xlYW4tZmlsZXMJOj0gKi5kdGIKZGlmZiAtLWdpdCBhL2FyY2gvYXJtNjQvYm9vdC9kdHMvYXJtL2p1bm8uZHRzIGIvYXJjaC9hcm02NC9ib290L2R0cy9hcm0vanVuby5kdHMKaW5kZXggY2IzMDczZS4uZDQyOTEyOSAxMDA2NDQKLS0tIGEvYXJjaC9hcm02NC9ib290L2R0cy9hcm0vanVuby5kdHMKKysrIGIvYXJjaC9hcm02NC9ib290L2R0cy9hcm0vanVuby5kdHMKQEAgLTIyLDcgKzIyLDcgQEAKIAl9OwogCiAJY2hvc2VuIHsKLQkJc3Rkb3V0LXBhdGggPSAmc29jX3VhcnQwOworCQlzdGRvdXQtcGF0aCA9ICJzZXJpYWwwOjExNTIwMG44IjsKIAl9OwogCiAJcHNjaSB7CmRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2bV9lbXVsYXRlLmggYi9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2bV9lbXVsYXRlLmgKaW5kZXggODY1YTdlMi4uM2NiNGM4NSAxMDA2NDQKLS0tIGEvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9rdm1fZW11bGF0ZS5oCisrKyBiL2FyY2gvYXJtNjQvaW5jbHVkZS9hc20va3ZtX2VtdWxhdGUuaApAQCAtNDUsNiArNDUsMTYgQEAKIAkJdmNwdS0+YXJjaC5oY3JfZWwyICY9IH5IQ1JfUlc7CiB9CiAKK3N0YXRpYyBpbmxpbmUgdW5zaWduZWQgbG9uZyB2Y3B1X2dldF9oY3Ioc3RydWN0IGt2bV92Y3B1ICp2Y3B1KQoreworCXJldHVybiB2Y3B1LT5hcmNoLmhjcl9lbDI7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCB2Y3B1X3NldF9oY3Ioc3RydWN0IGt2bV92Y3B1ICp2Y3B1LCB1bnNpZ25lZCBsb25nIGhjcikKK3sKKwl2Y3B1LT5hcmNoLmhjcl9lbDIgPSBoY3I7Cit9CisKIHN0YXRpYyBpbmxpbmUgdW5zaWduZWQgbG9uZyAqdmNwdV9wYyhjb25zdCBzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpCiB7CiAJcmV0dXJuICh1bnNpZ25lZCBsb25nICopJnZjcHVfZ3BfcmVncyh2Y3B1KS0+cmVncy5wYzsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtNjQvaW5jbHVkZS9hc20va3ZtX2hvc3QuaCBiL2FyY2gvYXJtNjQvaW5jbHVkZS9hc20va3ZtX2hvc3QuaAppbmRleCAwYjdkZmRiLi5hY2QxMDFhIDEwMDY0NAotLS0gYS9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2bV9ob3N0LmgKKysrIGIvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9rdm1faG9zdC5oCkBAIC0xMTYsOSArMTE2LDYgQEAKIAkgKiBBbnl0aGluZyB0aGF0IGlzIG5vdCB1c2VkIGRpcmVjdGx5IGZyb20gYXNzZW1ibHkgY29kZSBnb2VzCiAJICogaGVyZS4KIAkgKi8KLQkvKiBkY2FjaGUgc2V0L3dheSBvcGVyYXRpb24gcGVuZGluZyAqLwotCWludCBsYXN0X3BjcHU7Ci0JY3B1bWFza190IHJlcXVpcmVfZGNhY2hlX2ZsdXNoOwogCiAJLyogRG9uJ3QgcnVuIHRoZSBndWVzdCAqLwogCWJvb2wgcGF1c2U7CmRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2bV9tbXUuaCBiL2FyY2gvYXJtNjQvaW5jbHVkZS9hc20va3ZtX21tdS5oCmluZGV4IDE0YTc0ZjEuLmFkY2Y0OTUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtNjQvaW5jbHVkZS9hc20va3ZtX21tdS5oCisrKyBiL2FyY2gvYXJtNjQvaW5jbHVkZS9hc20va3ZtX21tdS5oCkBAIC0yNDMsMjQgKzI0Myw0NiBAQAogCXJldHVybiAodmNwdV9zeXNfcmVnKHZjcHUsIFNDVExSX0VMMSkgJiAwYjEwMSkgPT0gMGIxMDE7CiB9CiAKLXN0YXRpYyBpbmxpbmUgdm9pZCBjb2hlcmVudF9jYWNoZV9ndWVzdF9wYWdlKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwgaHZhX3QgaHZhLAotCQkJCQkgICAgIHVuc2lnbmVkIGxvbmcgc2l6ZSwKLQkJCQkJICAgICBib29sIGlwYV91bmNhY2hlZCkKK3N0YXRpYyBpbmxpbmUgdm9pZCBfX2NvaGVyZW50X2NhY2hlX2d1ZXN0X3BhZ2Uoc3RydWN0IGt2bV92Y3B1ICp2Y3B1LCBwZm5fdCBwZm4sCisJCQkJCSAgICAgICB1bnNpZ25lZCBsb25nIHNpemUsCisJCQkJCSAgICAgICBib29sIGlwYV91bmNhY2hlZCkKIHsKKwl2b2lkICp2YSA9IHBhZ2VfYWRkcmVzcyhwZm5fdG9fcGFnZShwZm4pKTsKKwogCWlmICghdmNwdV9oYXNfY2FjaGVfZW5hYmxlZCh2Y3B1KSB8fCBpcGFfdW5jYWNoZWQpCi0JCWt2bV9mbHVzaF9kY2FjaGVfdG9fcG9jKCh2b2lkICopaHZhLCBzaXplKTsKKwkJa3ZtX2ZsdXNoX2RjYWNoZV90b19wb2ModmEsIHNpemUpOwogCiAJaWYgKCFpY2FjaGVfaXNfYWxpYXNpbmcoKSkgewkJLyogUElQVCAqLwotCQlmbHVzaF9pY2FjaGVfcmFuZ2UoaHZhLCBodmEgKyBzaXplKTsKKwkJZmx1c2hfaWNhY2hlX3JhbmdlKCh1bnNpZ25lZCBsb25nKXZhLAorCQkJCSAgICh1bnNpZ25lZCBsb25nKXZhICsgc2l6ZSk7CiAJfSBlbHNlIGlmICghaWNhY2hlX2lzX2Fpdml2dCgpKSB7CS8qIG5vbiBBU0lELXRhZ2dlZCBWSVZUICovCiAJCS8qIGFueSBraW5kIG9mIFZJUFQgY2FjaGUgKi8KIAkJX19mbHVzaF9pY2FjaGVfYWxsKCk7CiAJfQogfQogCitzdGF0aWMgaW5saW5lIHZvaWQgX19rdm1fZmx1c2hfZGNhY2hlX3B0ZShwdGVfdCBwdGUpCit7CisJc3RydWN0IHBhZ2UgKnBhZ2UgPSBwdGVfcGFnZShwdGUpOworCWt2bV9mbHVzaF9kY2FjaGVfdG9fcG9jKHBhZ2VfYWRkcmVzcyhwYWdlKSwgUEFHRV9TSVpFKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIF9fa3ZtX2ZsdXNoX2RjYWNoZV9wbWQocG1kX3QgcG1kKQoreworCXN0cnVjdCBwYWdlICpwYWdlID0gcG1kX3BhZ2UocG1kKTsKKwlrdm1fZmx1c2hfZGNhY2hlX3RvX3BvYyhwYWdlX2FkZHJlc3MocGFnZSksIFBNRF9TSVpFKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIF9fa3ZtX2ZsdXNoX2RjYWNoZV9wdWQocHVkX3QgcHVkKQoreworCXN0cnVjdCBwYWdlICpwYWdlID0gcHVkX3BhZ2UocHVkKTsKKwlrdm1fZmx1c2hfZGNhY2hlX3RvX3BvYyhwYWdlX2FkZHJlc3MocGFnZSksIFBVRF9TSVpFKTsKK30KKwogI2RlZmluZSBrdm1fdmlydF90b19waHlzKHgpCQlfX3ZpcnRfdG9fcGh5cygodW5zaWduZWQgbG9uZykoeCkpCiAKLXZvaWQgc3RhZ2UyX2ZsdXNoX3ZtKHN0cnVjdCBrdm0gKmt2bSk7Cit2b2lkIGt2bV9zZXRfd2F5X2ZsdXNoKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSk7Cit2b2lkIGt2bV90b2dnbGVfY2FjaGUoc3RydWN0IGt2bV92Y3B1ICp2Y3B1LCBib29sIHdhc19lbmFibGVkKTsKIAogI2VuZGlmIC8qIF9fQVNTRU1CTFlfXyAqLwogI2VuZGlmIC8qIF9fQVJNNjRfS1ZNX01NVV9IX18gKi8KZGlmZiAtLWdpdCBhL2FyY2gvYXJtNjQva3ZtL3N5c19yZWdzLmMgYi9hcmNoL2FybTY0L2t2bS9zeXNfcmVncy5jCmluZGV4IDNkN2MyZGYuLmYzMWU4YmIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtNjQva3ZtL3N5c19yZWdzLmMKKysrIGIvYXJjaC9hcm02NC9rdm0vc3lzX3JlZ3MuYwpAQCAtNjksNjggKzY5LDMxIEBACiAJcmV0dXJuIGNjc2lkcjsKIH0KIAotc3RhdGljIHZvaWQgZG9fZGNfY2lzdyh1MzIgdmFsKQotewotCWFzbSB2b2xhdGlsZSgiZGMgY2lzdywgJXgwIiA6IDogInIiICh2YWwpKTsKLQlkc2IoaXNoKTsKLX0KLQotc3RhdGljIHZvaWQgZG9fZGNfY3N3KHUzMiB2YWwpCi17Ci0JYXNtIHZvbGF0aWxlKCJkYyBjc3csICV4MCIgOiA6ICJyIiAodmFsKSk7Ci0JZHNiKGlzaCk7Ci19Ci0KLS8qIFNlZSBub3RlIGF0IEFSTSBBUk0gQjEuMTQuNCAqLworLyoKKyAqIFNlZSBub3RlIGF0IEFSTXY3IEFSTSBCMS4xNC40IChUTDtEUjogUy9XIG9wcyBhcmUgbm90IGVhc2lseSB2aXJ0dWFsaXplZCkuCisgKi8KIHN0YXRpYyBib29sIGFjY2Vzc19kY3N3KHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwKIAkJCWNvbnN0IHN0cnVjdCBzeXNfcmVnX3BhcmFtcyAqcCwKIAkJCWNvbnN0IHN0cnVjdCBzeXNfcmVnX2Rlc2MgKnIpCiB7Ci0JdW5zaWduZWQgbG9uZyB2YWw7Ci0JaW50IGNwdTsKLQogCWlmICghcC0+aXNfd3JpdGUpCiAJCXJldHVybiByZWFkX2Zyb21fd3JpdGVfb25seSh2Y3B1LCBwKTsKIAotCWNwdSA9IGdldF9jcHUoKTsKLQotCWNwdW1hc2tfc2V0YWxsKCZ2Y3B1LT5hcmNoLnJlcXVpcmVfZGNhY2hlX2ZsdXNoKTsKLQljcHVtYXNrX2NsZWFyX2NwdShjcHUsICZ2Y3B1LT5hcmNoLnJlcXVpcmVfZGNhY2hlX2ZsdXNoKTsKLQotCS8qIElmIHdlIHdlcmUgYWxyZWFkeSBwcmVlbXB0ZWQsIHRha2UgdGhlIGxvbmcgd2F5IGFyb3VuZCAqLwotCWlmIChjcHUgIT0gdmNwdS0+YXJjaC5sYXN0X3BjcHUpIHsKLQkJZmx1c2hfY2FjaGVfYWxsKCk7Ci0JCWdvdG8gZG9uZTsKLQl9Ci0KLQl2YWwgPSAqdmNwdV9yZWcodmNwdSwgcC0+UnQpOwotCi0Jc3dpdGNoIChwLT5DUm0pIHsKLQljYXNlIDY6CQkJLyogVXBncmFkZSBEQ0lTVyB0byBEQ0NJU1csIGFzIHBlciBIQ1IuU1dJTyAqLwotCWNhc2UgMTQ6CQkvKiBEQ0NJU1cgKi8KLQkJZG9fZGNfY2lzdyh2YWwpOwotCQlicmVhazsKLQotCWNhc2UgMTA6CQkvKiBEQ0NTVyAqLwotCQlkb19kY19jc3codmFsKTsKLQkJYnJlYWs7Ci0JfQotCi1kb25lOgotCXB1dF9jcHUoKTsKLQorCWt2bV9zZXRfd2F5X2ZsdXNoKHZjcHUpOwogCXJldHVybiB0cnVlOwogfQogCiAvKgogICogR2VuZXJpYyBhY2Nlc3NvciBmb3IgVk0gcmVnaXN0ZXJzLiBPbmx5IGNhbGxlZCBhcyBsb25nIGFzIEhDUl9UVk0KLSAqIGlzIHNldC4KKyAqIGlzIHNldC4gSWYgdGhlIGd1ZXN0IGVuYWJsZXMgdGhlIE1NVSwgd2Ugc3RvcCB0cmFwcGluZyB0aGUgVk0KKyAqIHN5c19yZWdzIGFuZCBsZWF2ZSBpdCBpbiBjb21wbGV0ZSBjb250cm9sIG9mIHRoZSBjYWNoZXMuCiAgKi8KIHN0YXRpYyBib29sIGFjY2Vzc192bV9yZWcoc3RydWN0IGt2bV92Y3B1ICp2Y3B1LAogCQkJICBjb25zdCBzdHJ1Y3Qgc3lzX3JlZ19wYXJhbXMgKnAsCiAJCQkgIGNvbnN0IHN0cnVjdCBzeXNfcmVnX2Rlc2MgKnIpCiB7CiAJdW5zaWduZWQgbG9uZyB2YWw7CisJYm9vbCB3YXNfZW5hYmxlZCA9IHZjcHVfaGFzX2NhY2hlX2VuYWJsZWQodmNwdSk7CiAKIAlCVUdfT04oIXAtPmlzX3dyaXRlKTsKIApAQCAtMTQzLDI1ICsxMDYsNyBAQAogCQl2Y3B1X2NwMTVfNjRfbG93KHZjcHUsIHItPnJlZykgPSB2YWwgJiAweGZmZmZmZmZmVUw7CiAJfQogCi0JcmV0dXJuIHRydWU7Ci19Ci0KLS8qCi0gKiBTQ1RMUl9FTDEgYWNjZXNzb3IuIE9ubHkgY2FsbGVkIGFzIGxvbmcgYXMgSENSX1RWTSBpcyBzZXQuICBJZiB0aGUKLSAqIGd1ZXN0IGVuYWJsZXMgdGhlIE1NVSwgd2Ugc3RvcCB0cmFwcGluZyB0aGUgVk0gc3lzX3JlZ3MgYW5kIGxlYXZlCi0gKiBpdCBpbiBjb21wbGV0ZSBjb250cm9sIG9mIHRoZSBjYWNoZXMuCi0gKi8KLXN0YXRpYyBib29sIGFjY2Vzc19zY3RscihzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUsCi0JCQkgY29uc3Qgc3RydWN0IHN5c19yZWdfcGFyYW1zICpwLAotCQkJIGNvbnN0IHN0cnVjdCBzeXNfcmVnX2Rlc2MgKnIpCi17Ci0JYWNjZXNzX3ZtX3JlZyh2Y3B1LCBwLCByKTsKLQotCWlmICh2Y3B1X2hhc19jYWNoZV9lbmFibGVkKHZjcHUpKSB7CS8qIE1NVStDYWNoZXMgZW5hYmxlZD8gKi8KLQkJdmNwdS0+YXJjaC5oY3JfZWwyICY9IH5IQ1JfVFZNOwotCQlzdGFnZTJfZmx1c2hfdm0odmNwdS0+a3ZtKTsKLQl9Ci0KKwlrdm1fdG9nZ2xlX2NhY2hlKHZjcHUsIHdhc19lbmFibGVkKTsKIAlyZXR1cm4gdHJ1ZTsKIH0KIApAQCAtMzc3LDcgKzMyMiw3IEBACiAJICBOVUxMLCByZXNldF9tcGlkciwgTVBJRFJfRUwxIH0sCiAJLyogU0NUTFJfRUwxICovCiAJeyBPcDAoMGIxMSksIE9wMSgwYjAwMCksIENSbigwYjAwMDEpLCBDUm0oMGIwMDAwKSwgT3AyKDBiMDAwKSwKLQkgIGFjY2Vzc19zY3RsciwgcmVzZXRfdmFsLCBTQ1RMUl9FTDEsIDB4MDBDNTAwNzggfSwKKwkgIGFjY2Vzc192bV9yZWcsIHJlc2V0X3ZhbCwgU0NUTFJfRUwxLCAweDAwQzUwMDc4IH0sCiAJLyogQ1BBQ1JfRUwxICovCiAJeyBPcDAoMGIxMSksIE9wMSgwYjAwMCksIENSbigwYjAwMDEpLCBDUm0oMGIwMDAwKSwgT3AyKDBiMDEwKSwKIAkgIE5VTEwsIHJlc2V0X3ZhbCwgQ1BBQ1JfRUwxLCAwIH0sCkBAIC02NTcsNyArNjAyLDcgQEAKICAqIHJlZ2lzdGVyKS4KICAqLwogc3RhdGljIGNvbnN0IHN0cnVjdCBzeXNfcmVnX2Rlc2MgY3AxNV9yZWdzW10gPSB7Ci0JeyBPcDEoIDApLCBDUm4oIDEpLCBDUm0oIDApLCBPcDIoIDApLCBhY2Nlc3Nfc2N0bHIsIE5VTEwsIGMxX1NDVExSIH0sCisJeyBPcDEoIDApLCBDUm4oIDEpLCBDUm0oIDApLCBPcDIoIDApLCBhY2Nlc3Nfdm1fcmVnLCBOVUxMLCBjMV9TQ1RMUiB9LAogCXsgT3AxKCAwKSwgQ1JuKCAyKSwgQ1JtKCAwKSwgT3AyKCAwKSwgYWNjZXNzX3ZtX3JlZywgTlVMTCwgYzJfVFRCUjAgfSwKIAl7IE9wMSggMCksIENSbiggMiksIENSbSggMCksIE9wMiggMSksIGFjY2Vzc192bV9yZWcsIE5VTEwsIGMyX1RUQlIxIH0sCiAJeyBPcDEoIDApLCBDUm4oIDIpLCBDUm0oIDApLCBPcDIoIDIpLCBhY2Nlc3Nfdm1fcmVnLCBOVUxMLCBjMl9UVEJDUiB9LApkaWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9tbS9kdW1wLmMgYi9hcmNoL2FybTY0L21tL2R1bXAuYwppbmRleCBjZjMzZjMzLi5kNTRkYzlhIDEwMDY0NAotLS0gYS9hcmNoL2FybTY0L21tL2R1bXAuYworKysgYi9hcmNoL2FybTY0L21tL2R1bXAuYwpAQCAtMTUsNiArMTUsNyBAQAogICovCiAjaW5jbHVkZSA8bGludXgvZGVidWdmcy5oPgogI2luY2x1ZGUgPGxpbnV4L2ZzLmg+CisjaW5jbHVkZSA8bGludXgvaW8uaD4KICNpbmNsdWRlIDxsaW51eC9tbS5oPgogI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc2VxX2ZpbGUuaD4KZGlmZiAtLWdpdCBhL2FyY2gvYXZyMzIva2VybmVsL21vZHVsZS5jIGIvYXJjaC9hdnIzMi9rZXJuZWwvbW9kdWxlLmMKaW5kZXggMmM5NDEyOS4uMTY0ZWZhMCAxMDA2NDQKLS0tIGEvYXJjaC9hdnIzMi9rZXJuZWwvbW9kdWxlLmMKKysrIGIvYXJjaC9hdnIzMi9rZXJuZWwvbW9kdWxlLmMKQEAgLTE5LDEyICsxOSwxMCBAQAogI2luY2x1ZGUgPGxpbnV4L21vZHVsZWxvYWRlci5oPgogI2luY2x1ZGUgPGxpbnV4L3ZtYWxsb2MuaD4KIAotdm9pZCBtb2R1bGVfZnJlZShzdHJ1Y3QgbW9kdWxlICptb2QsIHZvaWQgKm1vZHVsZV9yZWdpb24pCit2b2lkIG1vZHVsZV9hcmNoX2ZyZWVpbmdfaW5pdChzdHJ1Y3QgbW9kdWxlICptb2QpCiB7CiAJdmZyZWUobW9kLT5hcmNoLnN5bWluZm8pOwogCW1vZC0+YXJjaC5zeW1pbmZvID0gTlVMTDsKLQotCXZmcmVlKG1vZHVsZV9yZWdpb24pOwogfQogCiBzdGF0aWMgaW5saW5lIGludCBjaGVja19yZWxhKEVsZjMyX1JlbGEgKnJlbGEsIHN0cnVjdCBtb2R1bGUgKm1vZHVsZSwKQEAgLTI5MSwxMiArMjg5LDMgQEAKIAogCXJldHVybiByZXQ7CiB9Ci0KLWludCBtb2R1bGVfZmluYWxpemUoY29uc3QgRWxmX0VoZHIgKmhkciwgY29uc3QgRWxmX1NoZHIgKnNlY2hkcnMsCi0JCSAgICBzdHJ1Y3QgbW9kdWxlICptb2R1bGUpCi17Ci0JdmZyZWUobW9kdWxlLT5hcmNoLnN5bWluZm8pOwotCW1vZHVsZS0+YXJjaC5zeW1pbmZvID0gTlVMTDsKLQotCXJldHVybiAwOwotfQpkaWZmIC0tZ2l0IGEvYXJjaC9hdnIzMi9tbS9mYXVsdC5jIGIvYXJjaC9hdnIzMi9tbS9mYXVsdC5jCmluZGV4IDBlY2E5MzMuLmQyMjNhOGIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXZyMzIvbW0vZmF1bHQuYworKysgYi9hcmNoL2F2cjMyL21tL2ZhdWx0LmMKQEAgLTE0Miw2ICsxNDIsOCBAQAogCWlmICh1bmxpa2VseShmYXVsdCAmIFZNX0ZBVUxUX0VSUk9SKSkgewogCQlpZiAoZmF1bHQgJiBWTV9GQVVMVF9PT00pCiAJCQlnb3RvIG91dF9vZl9tZW1vcnk7CisJCWVsc2UgaWYgKGZhdWx0ICYgVk1fRkFVTFRfU0lHU0VHVikKKwkJCWdvdG8gYmFkX2FyZWE7CiAJCWVsc2UgaWYgKGZhdWx0ICYgVk1fRkFVTFRfU0lHQlVTKQogCQkJZ290byBkb19zaWdidXM7CiAJCUJVRygpOwpkaWZmIC0tZ2l0IGEvYXJjaC9jcmlzL2FyY2gtdjMyL2RyaXZlcnMvc3luY19zZXJpYWwuYyBiL2FyY2gvY3Jpcy9hcmNoLXYzMi9kcml2ZXJzL3N5bmNfc2VyaWFsLmMKaW5kZXggMDhhMzEzZi4uZjc3MjA2OCAxMDA2NDQKLS0tIGEvYXJjaC9jcmlzL2FyY2gtdjMyL2RyaXZlcnMvc3luY19zZXJpYWwuYworKysgYi9hcmNoL2NyaXMvYXJjaC12MzIvZHJpdmVycy9zeW5jX3NlcmlhbC5jCkBAIC02MDQsNyArNjA0LDcgQEAKIAkJCQkgIHN0cnVjdCB0aW1lc3BlYyAqdHMpCiB7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKLQlpbnQgZGV2ID0gTUlOT1IoZmlsZS0+Zl9kZW50cnktPmRfaW5vZGUtPmlfcmRldik7CisJaW50IGRldiA9IE1JTk9SKGZpbGVfaW5vZGUoZmlsZSktPmlfcmRldik7CiAJaW50IGF2YWlsOwogCXN0cnVjdCBzeW5jX3BvcnQgKnBvcnQ7CiAJdW5zaWduZWQgY2hhciAqc3RhcnQ7CmRpZmYgLS1naXQgYS9hcmNoL2NyaXMva2VybmVsL21vZHVsZS5jIGIvYXJjaC9jcmlzL2tlcm5lbC9tb2R1bGUuYwppbmRleCA1MTEyM2Y5Li5hZjA0Y2I2IDEwMDY0NAotLS0gYS9hcmNoL2NyaXMva2VybmVsL21vZHVsZS5jCisrKyBiL2FyY2gvY3Jpcy9rZXJuZWwvbW9kdWxlLmMKQEAgLTM2LDcgKzM2LDcgQEAKIH0KIAogLyogRnJlZSBtZW1vcnkgcmV0dXJuZWQgZnJvbSBtb2R1bGVfYWxsb2MgKi8KLXZvaWQgbW9kdWxlX2ZyZWUoc3RydWN0IG1vZHVsZSAqbW9kLCB2b2lkICptb2R1bGVfcmVnaW9uKQordm9pZCBtb2R1bGVfbWVtZnJlZSh2b2lkICptb2R1bGVfcmVnaW9uKQogewogCWtmcmVlKG1vZHVsZV9yZWdpb24pOwogfQpkaWZmIC0tZ2l0IGEvYXJjaC9jcmlzL21tL2ZhdWx0LmMgYi9hcmNoL2NyaXMvbW0vZmF1bHQuYwppbmRleCAxNzkwZjIyLi4yNjg2YTdhIDEwMDY0NAotLS0gYS9hcmNoL2NyaXMvbW0vZmF1bHQuYworKysgYi9hcmNoL2NyaXMvbW0vZmF1bHQuYwpAQCAtMTc2LDYgKzE3Niw4IEBACiAJaWYgKHVubGlrZWx5KGZhdWx0ICYgVk1fRkFVTFRfRVJST1IpKSB7CiAJCWlmIChmYXVsdCAmIFZNX0ZBVUxUX09PTSkKIAkJCWdvdG8gb3V0X29mX21lbW9yeTsKKwkJZWxzZSBpZiAoZmF1bHQgJiBWTV9GQVVMVF9TSUdTRUdWKQorCQkJZ290byBiYWRfYXJlYTsKIAkJZWxzZSBpZiAoZmF1bHQgJiBWTV9GQVVMVF9TSUdCVVMpCiAJCQlnb3RvIGRvX3NpZ2J1czsKIAkJQlVHKCk7CmRpZmYgLS1naXQgYS9hcmNoL2Zydi9tYjkzMDkwLW1iMDAvcGNpLWZydi5jIGIvYXJjaC9mcnYvbWI5MzA5MC1tYjAwL3BjaS1mcnYuYwppbmRleCA2N2IxZDE2Li4wNjM1YmQ2IDEwMDY0NAotLS0gYS9hcmNoL2Zydi9tYjkzMDkwLW1iMDAvcGNpLWZydi5jCisrKyBiL2FyY2gvZnJ2L21iOTMwOTAtbWIwMC9wY2ktZnJ2LmMKQEAgLTk0LDcgKzk0LDcgQEAKIAkJCQlyID0gJmRldi0+cmVzb3VyY2VbaWR4XTsKIAkJCQlpZiAoIXItPnN0YXJ0KQogCQkJCQljb250aW51ZTsKLQkJCQlwY2lfY2xhaW1fcmVzb3VyY2UoZGV2LCBpZHgpOworCQkJCXBjaV9jbGFpbV9icmlkZ2VfcmVzb3VyY2UoZGV2LCBpZHgpOwogCQkJfQogCQl9CiAJCXBjaWJpb3NfYWxsb2NhdGVfYnVzX3Jlc291cmNlcygmYnVzLT5jaGlsZHJlbik7CmRpZmYgLS1naXQgYS9hcmNoL2Zydi9tbS9mYXVsdC5jIGIvYXJjaC9mcnYvbW0vZmF1bHQuYwppbmRleCA5YTY2MzcyLi5lYzQ5MTdkIDEwMDY0NAotLS0gYS9hcmNoL2Zydi9tbS9mYXVsdC5jCisrKyBiL2FyY2gvZnJ2L21tL2ZhdWx0LmMKQEAgLTE2OCw2ICsxNjgsOCBAQAogCWlmICh1bmxpa2VseShmYXVsdCAmIFZNX0ZBVUxUX0VSUk9SKSkgewogCQlpZiAoZmF1bHQgJiBWTV9GQVVMVF9PT00pCiAJCQlnb3RvIG91dF9vZl9tZW1vcnk7CisJCWVsc2UgaWYgKGZhdWx0ICYgVk1fRkFVTFRfU0lHU0VHVikKKwkJCWdvdG8gYmFkX2FyZWE7CiAJCWVsc2UgaWYgKGZhdWx0ICYgVk1fRkFVTFRfU0lHQlVTKQogCQkJZ290byBkb19zaWdidXM7CiAJCUJVRygpOwpkaWZmIC0tZ2l0IGEvYXJjaC9pYTY0L2tlcm5lbC9hY3BpLWV4dC5jIGIvYXJjaC9pYTY0L2tlcm5lbC9hY3BpLWV4dC5jCmluZGV4IDhiOTMxOGQuLmJkMDliZjcgMTAwNjQ0Ci0tLSBhL2FyY2gvaWE2NC9rZXJuZWwvYWNwaS1leHQuYworKysgYi9hcmNoL2lhNjQva2VybmVsL2FjcGktZXh0LmMKQEAgLTY5LDEwICs2OSwxMCBAQAogCXN0YXR1cyA9IGFjcGlfcmVzb3VyY2VfdG9fYWRkcmVzczY0KHJlc291cmNlLCAmYWRkcik7CiAJaWYgKEFDUElfU1VDQ0VTUyhzdGF0dXMpICYmCiAJICAgIGFkZHIucmVzb3VyY2VfdHlwZSA9PSBBQ1BJX01FTU9SWV9SQU5HRSAmJgotCSAgICBhZGRyLmFkZHJlc3NfbGVuZ3RoICYmCisJICAgIGFkZHIuYWRkcmVzcy5hZGRyZXNzX2xlbmd0aCAmJgogCSAgICBhZGRyLnByb2R1Y2VyX2NvbnN1bWVyID09IEFDUElfQ09OU1VNRVIpIHsKLQkJc3BhY2UtPmJhc2UgPSBhZGRyLm1pbmltdW07Ci0JCXNwYWNlLT5sZW5ndGggPSBhZGRyLmFkZHJlc3NfbGVuZ3RoOworCQlzcGFjZS0+YmFzZSA9IGFkZHIuYWRkcmVzcy5taW5pbXVtOworCQlzcGFjZS0+bGVuZ3RoID0gYWRkci5hZGRyZXNzLmFkZHJlc3NfbGVuZ3RoOwogCQlyZXR1cm4gQUVfQ1RSTF9URVJNSU5BVEU7CiAJfQogCXJldHVybiBBRV9PSzsJCS8qIGtlZXAgbG9va2luZyAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9pYTY0L2tlcm5lbC9hY3BpLmMgYi9hcmNoL2lhNjQva2VybmVsL2FjcGkuYwppbmRleCBlNzk1Y2I4Li4yYzQ0OTg5IDEwMDY0NAotLS0gYS9hcmNoL2lhNjQva2VybmVsL2FjcGkuYworKysgYi9hcmNoL2lhNjQva2VybmVsL2FjcGkuYwpAQCAtMzgwLDkgKzM4MCw2IEBACiAKIHN0YXRpYyBpbnQgX19pbml0IGFjcGlfcGFyc2VfbWFkdChzdHJ1Y3QgYWNwaV90YWJsZV9oZWFkZXIgKnRhYmxlKQogewotCWlmICghdGFibGUpCi0JCXJldHVybiAtRUlOVkFMOwotCiAJYWNwaV9tYWR0ID0gKHN0cnVjdCBhY3BpX3RhYmxlX21hZHQgKil0YWJsZTsKIAogCWFjcGlfbWFkdF9yZXYgPSBhY3BpX21hZHQtPmhlYWRlci5yZXZpc2lvbjsKQEAgLTY0NSw5ICs2NDIsNiBAQAogCXN0cnVjdCBhY3BpX3RhYmxlX2hlYWRlciAqZmFkdF9oZWFkZXI7CiAJc3RydWN0IGFjcGlfdGFibGVfZmFkdCAqZmFkdDsKIAotCWlmICghdGFibGUpCi0JCXJldHVybiAtRUlOVkFMOwotCiAJZmFkdF9oZWFkZXIgPSAoc3RydWN0IGFjcGlfdGFibGVfaGVhZGVyICopdGFibGU7CiAJaWYgKGZhZHRfaGVhZGVyLT5yZXZpc2lvbiAhPSAzKQogCQlyZXR1cm4gLUVOT0RFVjsJLyogT25seSBkZWFsIHdpdGggQUNQSSAyLjAgRkFEVCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9pYTY0L2tlcm5lbC9tb2R1bGUuYyBiL2FyY2gvaWE2NC9rZXJuZWwvbW9kdWxlLmMKaW5kZXggMjQ2MDNiZS4uMjk3NTRhYSAxMDA2NDQKLS0tIGEvYXJjaC9pYTY0L2tlcm5lbC9tb2R1bGUuYworKysgYi9hcmNoL2lhNjQva2VybmVsL21vZHVsZS5jCkBAIC0zMDUsMTQgKzMwNSwxMiBAQAogI2VuZGlmIC8qICFVU0VfQlJMICovCiAKIHZvaWQKLW1vZHVsZV9mcmVlIChzdHJ1Y3QgbW9kdWxlICptb2QsIHZvaWQgKm1vZHVsZV9yZWdpb24pCittb2R1bGVfYXJjaF9mcmVlaW5nX2luaXQgKHN0cnVjdCBtb2R1bGUgKm1vZCkKIHsKLQlpZiAobW9kICYmIG1vZC0+YXJjaC5pbml0X3Vud190YWJsZSAmJgotCSAgICBtb2R1bGVfcmVnaW9uID09IG1vZC0+bW9kdWxlX2luaXQpIHsKKwlpZiAobW9kLT5hcmNoLmluaXRfdW53X3RhYmxlKSB7CiAJCXVud19yZW1vdmVfdW53aW5kX3RhYmxlKG1vZC0+YXJjaC5pbml0X3Vud190YWJsZSk7CiAJCW1vZC0+YXJjaC5pbml0X3Vud190YWJsZSA9IE5VTEw7CiAJfQotCXZmcmVlKG1vZHVsZV9yZWdpb24pOwogfQogCiAvKiBIYXZlIHdlIGFscmVhZHkgc2VlbiBvbmUgb2YgdGhlc2UgcmVsb2NhdGlvbnM/ICovCmRpZmYgLS1naXQgYS9hcmNoL2lhNjQvbW0vZmF1bHQuYyBiL2FyY2gvaWE2NC9tbS9mYXVsdC5jCmluZGV4IDcyMjVkYWQuLmJhNWJhN2EgMTAwNjQ0Ci0tLSBhL2FyY2gvaWE2NC9tbS9mYXVsdC5jCisrKyBiL2FyY2gvaWE2NC9tbS9mYXVsdC5jCkBAIC0xNzIsNiArMTcyLDggQEAKIAkJICovCiAJCWlmIChmYXVsdCAmIFZNX0ZBVUxUX09PTSkgewogCQkJZ290byBvdXRfb2ZfbWVtb3J5OworCQl9IGVsc2UgaWYgKGZhdWx0ICYgVk1fRkFVTFRfU0lHU0VHVikgeworCQkJZ290byBiYWRfYXJlYTsKIAkJfSBlbHNlIGlmIChmYXVsdCAmIFZNX0ZBVUxUX1NJR0JVUykgewogCQkJc2lnbmFsID0gU0lHQlVTOwogCQkJZ290byBiYWRfYXJlYTsKZGlmZiAtLWdpdCBhL2FyY2gvaWE2NC9wY2kvcGNpLmMgYi9hcmNoL2lhNjQvcGNpL3BjaS5jCmluZGV4IDI5MWE1ODIuLjQ4Y2M2NTcgMTAwNjQ0Ci0tLSBhL2FyY2gvaWE2NC9wY2kvcGNpLmMKKysrIGIvYXJjaC9pYTY0L3BjaS9wY2kuYwpAQCAtMTg4LDEyICsxODgsMTIgQEAKIAogCW5hbWUgPSAoY2hhciAqKShpb3NwYWNlICsgMSk7CiAKLQltaW4gPSBhZGRyLT5taW5pbXVtOwotCW1heCA9IG1pbiArIGFkZHItPmFkZHJlc3NfbGVuZ3RoIC0gMTsKKwltaW4gPSBhZGRyLT5hZGRyZXNzLm1pbmltdW07CisJbWF4ID0gbWluICsgYWRkci0+YWRkcmVzcy5hZGRyZXNzX2xlbmd0aCAtIDE7CiAJaWYgKGFkZHItPmluZm8uaW8udHJhbnNsYXRpb25fdHlwZSA9PSBBQ1BJX1NQQVJTRV9UUkFOU0xBVElPTikKIAkJc3BhcnNlID0gMTsKIAotCXNwYWNlX25yID0gbmV3X3NwYWNlKGFkZHItPnRyYW5zbGF0aW9uX29mZnNldCwgc3BhcnNlKTsKKwlzcGFjZV9uciA9IG5ld19zcGFjZShhZGRyLT5hZGRyZXNzLnRyYW5zbGF0aW9uX29mZnNldCwgc3BhcnNlKTsKIAlpZiAoc3BhY2VfbnIgPT0gfjApCiAJCWdvdG8gZnJlZV9yZXNvdXJjZTsKIApAQCAtMjQ3LDcgKzI0Nyw3IEBACiAJaWYgKEFDUElfU1VDQ0VTUyhzdGF0dXMpICYmCiAJICAgIChhZGRyLT5yZXNvdXJjZV90eXBlID09IEFDUElfTUVNT1JZX1JBTkdFIHx8CiAJICAgICBhZGRyLT5yZXNvdXJjZV90eXBlID09IEFDUElfSU9fUkFOR0UpICYmCi0JICAgIGFkZHItPmFkZHJlc3NfbGVuZ3RoICYmCisJICAgIGFkZHItPmFkZHJlc3MuYWRkcmVzc19sZW5ndGggJiYKIAkgICAgYWRkci0+cHJvZHVjZXJfY29uc3VtZXIgPT0gQUNQSV9QUk9EVUNFUikKIAkJcmV0dXJuIEFFX09LOwogCkBAIC0yODQsNyArMjg0LDcgQEAKIAlpZiAoYWRkci5yZXNvdXJjZV90eXBlID09IEFDUElfTUVNT1JZX1JBTkdFKSB7CiAJCWZsYWdzID0gSU9SRVNPVVJDRV9NRU07CiAJCXJvb3QgPSAmaW9tZW1fcmVzb3VyY2U7Ci0JCW9mZnNldCA9IGFkZHIudHJhbnNsYXRpb25fb2Zmc2V0OworCQlvZmZzZXQgPSBhZGRyLmFkZHJlc3MudHJhbnNsYXRpb25fb2Zmc2V0OwogCX0gZWxzZSBpZiAoYWRkci5yZXNvdXJjZV90eXBlID09IEFDUElfSU9fUkFOR0UpIHsKIAkJZmxhZ3MgPSBJT1JFU09VUkNFX0lPOwogCQlyb290ID0gJmlvcG9ydF9yZXNvdXJjZTsKQEAgLTI5Nyw4ICsyOTcsOCBAQAogCXJlc291cmNlID0gJmluZm8tPnJlc1tpbmZvLT5yZXNfbnVtXTsKIAlyZXNvdXJjZS0+bmFtZSA9IGluZm8tPm5hbWU7CiAJcmVzb3VyY2UtPmZsYWdzID0gZmxhZ3M7Ci0JcmVzb3VyY2UtPnN0YXJ0ID0gYWRkci5taW5pbXVtICsgb2Zmc2V0OwotCXJlc291cmNlLT5lbmQgPSByZXNvdXJjZS0+c3RhcnQgKyBhZGRyLmFkZHJlc3NfbGVuZ3RoIC0gMTsKKwlyZXNvdXJjZS0+c3RhcnQgPSBhZGRyLmFkZHJlc3MubWluaW11bSArIG9mZnNldDsKKwlyZXNvdXJjZS0+ZW5kID0gcmVzb3VyY2UtPnN0YXJ0ICsgYWRkci5hZGRyZXNzLmFkZHJlc3NfbGVuZ3RoIC0gMTsKIAlpbmZvLT5yZXNfb2Zmc2V0W2luZm8tPnJlc19udW1dID0gb2Zmc2V0OwogCiAJaWYgKGluc2VydF9yZXNvdXJjZShyb290LCByZXNvdXJjZSkpIHsKQEAgLTQ4Nyw0NSArNDg3LDM5IEBACiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyBpbnQgaXNfdmFsaWRfcmVzb3VyY2Uoc3RydWN0IHBjaV9kZXYgKmRldiwgaW50IGlkeCkKLXsKLQl1bnNpZ25lZCBpbnQgaSwgdHlwZV9tYXNrID0gSU9SRVNPVVJDRV9JTyB8IElPUkVTT1VSQ0VfTUVNOwotCXN0cnVjdCByZXNvdXJjZSAqZGV2ciA9ICZkZXYtPnJlc291cmNlW2lkeF0sICpidXNyOwotCi0JaWYgKCFkZXYtPmJ1cykKLQkJcmV0dXJuIDA7Ci0KLQlwY2lfYnVzX2Zvcl9lYWNoX3Jlc291cmNlKGRldi0+YnVzLCBidXNyLCBpKSB7Ci0JCWlmICghYnVzciB8fCAoKGJ1c3ItPmZsYWdzIF4gZGV2ci0+ZmxhZ3MpICYgdHlwZV9tYXNrKSkKLQkJCWNvbnRpbnVlOwotCQlpZiAoKGRldnItPnN0YXJ0KSAmJiAoZGV2ci0+c3RhcnQgPj0gYnVzci0+c3RhcnQpICYmCi0JCQkJKGRldnItPmVuZCA8PSBidXNyLT5lbmQpKQotCQkJcmV0dXJuIDE7Ci0JfQotCXJldHVybiAwOwotfQotCi1zdGF0aWMgdm9pZCBwY2liaW9zX2ZpeHVwX3Jlc291cmNlcyhzdHJ1Y3QgcGNpX2RldiAqZGV2LCBpbnQgc3RhcnQsIGludCBsaW1pdCkKLXsKLQlpbnQgaTsKLQotCWZvciAoaSA9IHN0YXJ0OyBpIDwgbGltaXQ7IGkrKykgewotCQlpZiAoIWRldi0+cmVzb3VyY2VbaV0uZmxhZ3MpCi0JCQljb250aW51ZTsKLQkJaWYgKChpc192YWxpZF9yZXNvdXJjZShkZXYsIGkpKSkKLQkJCXBjaV9jbGFpbV9yZXNvdXJjZShkZXYsIGkpOwotCX0KLX0KLQogdm9pZCBwY2liaW9zX2ZpeHVwX2RldmljZV9yZXNvdXJjZXMoc3RydWN0IHBjaV9kZXYgKmRldikKIHsKLQlwY2liaW9zX2ZpeHVwX3Jlc291cmNlcyhkZXYsIDAsIFBDSV9CUklER0VfUkVTT1VSQ0VTKTsKKwlpbnQgaWR4OworCisJaWYgKCFkZXYtPmJ1cykKKwkJcmV0dXJuOworCisJZm9yIChpZHggPSAwOyBpZHggPCBQQ0lfQlJJREdFX1JFU09VUkNFUzsgaWR4KyspIHsKKwkJc3RydWN0IHJlc291cmNlICpyID0gJmRldi0+cmVzb3VyY2VbaWR4XTsKKworCQlpZiAoIXItPmZsYWdzIHx8IHItPnBhcmVudCB8fCAhci0+c3RhcnQpCisJCQljb250aW51ZTsKKworCQlwY2lfY2xhaW1fcmVzb3VyY2UoZGV2LCBpZHgpOworCX0KIH0KIEVYUE9SVF9TWU1CT0xfR1BMKHBjaWJpb3NfZml4dXBfZGV2aWNlX3Jlc291cmNlcyk7CiAKIHN0YXRpYyB2b2lkIHBjaWJpb3NfZml4dXBfYnJpZGdlX3Jlc291cmNlcyhzdHJ1Y3QgcGNpX2RldiAqZGV2KQogewotCXBjaWJpb3NfZml4dXBfcmVzb3VyY2VzKGRldiwgUENJX0JSSURHRV9SRVNPVVJDRVMsIFBDSV9OVU1fUkVTT1VSQ0VTKTsKKwlpbnQgaWR4OworCisJaWYgKCFkZXYtPmJ1cykKKwkJcmV0dXJuOworCisJZm9yIChpZHggPSBQQ0lfQlJJREdFX1JFU09VUkNFUzsgaWR4IDwgUENJX05VTV9SRVNPVVJDRVM7IGlkeCsrKSB7CisJCXN0cnVjdCByZXNvdXJjZSAqciA9ICZkZXYtPnJlc291cmNlW2lkeF07CisKKwkJaWYgKCFyLT5mbGFncyB8fCByLT5wYXJlbnQgfHwgIXItPnN0YXJ0KQorCQkJY29udGludWU7CisKKwkJcGNpX2NsYWltX2JyaWRnZV9yZXNvdXJjZShkZXYsIGlkeCk7CisJfQogfQogCiAvKgpkaWZmIC0tZ2l0IGEvYXJjaC9tMzJyL21tL2ZhdWx0LmMgYi9hcmNoL20zMnIvbW0vZmF1bHQuYwppbmRleCBlOWM2YTgwLi5lM2Q0ZDQ4OTAxIDEwMDY0NAotLS0gYS9hcmNoL20zMnIvbW0vZmF1bHQuYworKysgYi9hcmNoL20zMnIvbW0vZmF1bHQuYwpAQCAtMjAwLDYgKzIwMCw4IEBACiAJaWYgKHVubGlrZWx5KGZhdWx0ICYgVk1fRkFVTFRfRVJST1IpKSB7CiAJCWlmIChmYXVsdCAmIFZNX0ZBVUxUX09PTSkKIAkJCWdvdG8gb3V0X29mX21lbW9yeTsKKwkJZWxzZSBpZiAoZmF1bHQgJiBWTV9GQVVMVF9TSUdTRUdWKQorCQkJZ290byBiYWRfYXJlYTsKIAkJZWxzZSBpZiAoZmF1bHQgJiBWTV9GQVVMVF9TSUdCVVMpCiAJCQlnb3RvIGRvX3NpZ2J1czsKIAkJQlVHKCk7CmRpZmYgLS1naXQgYS9hcmNoL202OGsvbW0vZmF1bHQuYyBiL2FyY2gvbTY4ay9tbS9mYXVsdC5jCmluZGV4IDJiZDc0ODcuLmIyZjA0YWUgMTAwNjQ0Ci0tLSBhL2FyY2gvbTY4ay9tbS9mYXVsdC5jCisrKyBiL2FyY2gvbTY4ay9tbS9mYXVsdC5jCkBAIC0xNDUsNiArMTQ1LDggQEAKIAlpZiAodW5saWtlbHkoZmF1bHQgJiBWTV9GQVVMVF9FUlJPUikpIHsKIAkJaWYgKGZhdWx0ICYgVk1fRkFVTFRfT09NKQogCQkJZ290byBvdXRfb2ZfbWVtb3J5OworCQllbHNlIGlmIChmYXVsdCAmIFZNX0ZBVUxUX1NJR1NFR1YpCisJCQlnb3RvIG1hcF9lcnI7CiAJCWVsc2UgaWYgKGZhdWx0ICYgVk1fRkFVTFRfU0lHQlVTKQogCQkJZ290byBidXNfZXJyOwogCQlCVUcoKTsKZGlmZiAtLWdpdCBhL2FyY2gvbWV0YWcvbW0vZmF1bHQuYyBiL2FyY2gvbWV0YWcvbW0vZmF1bHQuYwppbmRleCAzMzI2ODBlLi4yZGU1ZGM2IDEwMDY0NAotLS0gYS9hcmNoL21ldGFnL21tL2ZhdWx0LmMKKysrIGIvYXJjaC9tZXRhZy9tbS9mYXVsdC5jCkBAIC0xNDEsNiArMTQxLDggQEAKIAlpZiAodW5saWtlbHkoZmF1bHQgJiBWTV9GQVVMVF9FUlJPUikpIHsKIAkJaWYgKGZhdWx0ICYgVk1fRkFVTFRfT09NKQogCQkJZ290byBvdXRfb2ZfbWVtb3J5OworCQllbHNlIGlmIChmYXVsdCAmIFZNX0ZBVUxUX1NJR1NFR1YpCisJCQlnb3RvIGJhZF9hcmVhOwogCQllbHNlIGlmIChmYXVsdCAmIFZNX0ZBVUxUX1NJR0JVUykKIAkJCWdvdG8gZG9fc2lnYnVzOwogCQlCVUcoKTsKZGlmZiAtLWdpdCBhL2FyY2gvbWljcm9ibGF6ZS9tbS9mYXVsdC5jIGIvYXJjaC9taWNyb2JsYXplL21tL2ZhdWx0LmMKaW5kZXggZmE0Y2Y1Mi4uZDQ2YTVlYiAxMDA2NDQKLS0tIGEvYXJjaC9taWNyb2JsYXplL21tL2ZhdWx0LmMKKysrIGIvYXJjaC9taWNyb2JsYXplL21tL2ZhdWx0LmMKQEAgLTIyNCw2ICsyMjQsOCBAQAogCWlmICh1bmxpa2VseShmYXVsdCAmIFZNX0ZBVUxUX0VSUk9SKSkgewogCQlpZiAoZmF1bHQgJiBWTV9GQVVMVF9PT00pCiAJCQlnb3RvIG91dF9vZl9tZW1vcnk7CisJCWVsc2UgaWYgKGZhdWx0ICYgVk1fRkFVTFRfU0lHU0VHVikKKwkJCWdvdG8gYmFkX2FyZWE7CiAJCWVsc2UgaWYgKGZhdWx0ICYgVk1fRkFVTFRfU0lHQlVTKQogCQkJZ290byBkb19zaWdidXM7CiAJCUJVRygpOwpkaWZmIC0tZ2l0IGEvYXJjaC9taWNyb2JsYXplL3BjaS9wY2ktY29tbW9uLmMgYi9hcmNoL21pY3JvYmxhemUvcGNpL3BjaS1jb21tb24uYwppbmRleCBiMzBlNDFjLi40ODUyOGZiIDEwMDY0NAotLS0gYS9hcmNoL21pY3JvYmxhemUvcGNpL3BjaS1jb21tb24uYworKysgYi9hcmNoL21pY3JvYmxhemUvcGNpL3BjaS1jb21tb24uYwpAQCAtMTAyNiw2ICsxMDI2LDggQEAKIAkJCSBwciwgKHByICYmIHByLT5uYW1lKSA/IHByLT5uYW1lIDogIm5pbCIpOwogCiAJCWlmIChwciAmJiAhKHByLT5mbGFncyAmIElPUkVTT1VSQ0VfVU5TRVQpKSB7CisJCQlzdHJ1Y3QgcGNpX2RldiAqZGV2ID0gYnVzLT5zZWxmOworCiAJCQlpZiAocmVxdWVzdF9yZXNvdXJjZShwciwgcmVzKSA9PSAwKQogCQkJCWNvbnRpbnVlOwogCQkJLyoKQEAgLTEwMzUsNiArMTAzNywxMiBAQAogCQkJICovCiAJCQlpZiAocmVwYXJlbnRfcmVzb3VyY2VzKHByLCByZXMpID09IDApCiAJCQkJY29udGludWU7CisKKwkJCWlmIChkZXYgJiYgaSA8IFBDSV9CUklER0VfUkVTT1VSQ0VfTlVNICYmCisJCQkgICAgcGNpX2NsYWltX2JyaWRnZV9yZXNvdXJjZShkZXYsCisJCQkJCQkgaSArIFBDSV9CUklER0VfUkVTT1VSQ0VTKSA9PSAwKQorCQkJCWNvbnRpbnVlOworCiAJCX0KIAkJcHJfd2FybigiUENJOiBDYW5ub3QgYWxsb2NhdGUgcmVzb3VyY2UgcmVnaW9uICIpOwogCQlwcl9jb250KCIlZCBvZiBQQ0kgYnJpZGdlICVkLCB3aWxsIHJlbWFwXG4iLCBpLCBidXMtPm51bWJlcik7CkBAIC0xMjI3LDcgKzEyMzUsMTAgQEAKIAkJCQkgKHVuc2lnbmVkIGxvbmcgbG9uZylyLT5lbmQsCiAJCQkJICh1bnNpZ25lZCBpbnQpci0+ZmxhZ3MpOwogCi0JCQlwY2lfY2xhaW1fcmVzb3VyY2UoZGV2LCBpKTsKKwkJCWlmIChwY2lfY2xhaW1fcmVzb3VyY2UoZGV2LCBpKSA9PSAwKQorCQkJCWNvbnRpbnVlOworCisJCQlwY2lfY2xhaW1fYnJpZGdlX3Jlc291cmNlKGRldiwgaSk7CiAJCX0KIAl9CiAKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9LY29uZmlnIGIvYXJjaC9taXBzL0tjb25maWcKaW5kZXggMzI4OTk2OS4uODQzNzEzYyAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL0tjb25maWcKKysrIGIvYXJjaC9taXBzL0tjb25maWcKQEAgLTI2NTYsMjcgKzI2NTYsMjEgQEAKIAlib29sCiAKIGNvbmZpZyBNSVBTMzJfQ09NUEFUCi0JYm9vbCAiS2VybmVsIHN1cHBvcnQgZm9yIExpbnV4L01JUFMgMzItYml0IGJpbmFyeSBjb21wYXRpYmlsaXR5IgotCWRlcGVuZHMgb24gNjRCSVQKLQloZWxwCi0JICBTZWxlY3QgdGhpcyBvcHRpb24gaWYgeW91IHdhbnQgTGludXgvTUlQUyAzMi1iaXQgYmluYXJ5Ci0JICBjb21wYXRpYmlsaXR5LiBTaW5jZSBhbGwgc29mdHdhcmUgYXZhaWxhYmxlIGZvciBMaW51eC9NSVBTIGlzCi0JICBjdXJyZW50bHkgMzItYml0IHlvdSBzaG91bGQgc2F5IFkgaGVyZS4KKwlib29sCiAKIGNvbmZpZyBDT01QQVQKIAlib29sCi0JZGVwZW5kcyBvbiBNSVBTMzJfQ09NUEFUCi0Jc2VsZWN0IEFSQ0hfV0FOVF9PTERfQ09NUEFUX0lQQwotCWRlZmF1bHQgeQogCiBjb25maWcgU1lTVklQQ19DT01QQVQKIAlib29sCi0JZGVwZW5kcyBvbiBDT01QQVQgJiYgU1lTVklQQwotCWRlZmF1bHQgeQogCiBjb25maWcgTUlQUzMyX08zMgogCWJvb2wgIktlcm5lbCBzdXBwb3J0IGZvciBvMzIgYmluYXJpZXMiCi0JZGVwZW5kcyBvbiBNSVBTMzJfQ09NUEFUCisJZGVwZW5kcyBvbiA2NEJJVAorCXNlbGVjdCBBUkNIX1dBTlRfT0xEX0NPTVBBVF9JUEMKKwlzZWxlY3QgQ09NUEFUCisJc2VsZWN0IE1JUFMzMl9DT01QQVQKKwlzZWxlY3QgU1lTVklQQ19DT01QQVQgaWYgU1lTVklQQwogCWhlbHAKIAkgIFNlbGVjdCB0aGlzIG9wdGlvbiBpZiB5b3Ugd2FudCB0byBydW4gbzMyIGJpbmFyaWVzLiAgVGhlc2UgYXJlIHB1cmUKIAkgIDMyLWJpdCBiaW5hcmllcyBhcyB1c2VkIGJ5IHRoZSAzMi1iaXQgTGludXgvTUlQUyBwb3J0LiAgTW9zdCBvZgpAQCAtMjY4Niw3ICsyNjgwLDEwIEBACiAKIGNvbmZpZyBNSVBTMzJfTjMyCiAJYm9vbCAiS2VybmVsIHN1cHBvcnQgZm9yIG4zMiBiaW5hcmllcyIKLQlkZXBlbmRzIG9uIE1JUFMzMl9DT01QQVQKKwlkZXBlbmRzIG9uIDY0QklUCisJc2VsZWN0IENPTVBBVAorCXNlbGVjdCBNSVBTMzJfQ09NUEFUCisJc2VsZWN0IFNZU1ZJUENfQ09NUEFUIGlmIFNZU1ZJUEMKIAloZWxwCiAJICBTZWxlY3QgdGhpcyBvcHRpb24gaWYgeW91IHdhbnQgdG8gcnVuIG4zMiBiaW5hcmllcy4gIFRoZXNlIGFyZQogCSAgNjQtYml0IGJpbmFyaWVzIHVzaW5nIDMyLWJpdCBxdWFudGl0aWVzIGZvciBhZGRyZXNzaW5nIGFuZCBjZXJ0YWluCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvYm9vdC9lbGYyZWNvZmYuYyBiL2FyY2gvbWlwcy9ib290L2VsZjJlY29mZi5jCmluZGV4IDg1ODUwNzguLjJhNGM1MmUgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9ib290L2VsZjJlY29mZi5jCisrKyBiL2FyY2gvbWlwcy9ib290L2VsZjJlY29mZi5jCkBAIC00OSw3ICs0OSw4IEBACiAvKgogICogU29tZSBleHRyYSBFTEYgZGVmaW5pdGlvbnMKICAqLwotI2RlZmluZSBQVF9NSVBTX1JFR0lORk8gMHg3MDAwMDAwMAkvKiBSZWdpc3RlciB1c2FnZSBpbmZvcm1hdGlvbiAqLworI2RlZmluZSBQVF9NSVBTX1JFR0lORk8gCTB4NzAwMDAwMDAJLyogUmVnaXN0ZXIgdXNhZ2UgaW5mb3JtYXRpb24gKi8KKyNkZWZpbmUgUFRfTUlQU19BQklGTEFHUwkweDcwMDAwMDAzCS8qIFJlY29yZHMgQUJJIHJlbGF0ZWQgZmxhZ3MgICovCiAKIC8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCiAKQEAgLTM0OSwzOSArMzUwLDQ2IEBACiAKIAlmb3IgKGkgPSAwOyBpIDwgZXguZV9waG51bTsgaSsrKSB7CiAJCS8qIFNlY3Rpb24gdHlwZXMgd2UgY2FuIGlnbm9yZS4uLiAqLwotCQlpZiAocGhbaV0ucF90eXBlID09IFBUX05VTEwgfHwgcGhbaV0ucF90eXBlID09IFBUX05PVEUgfHwKLQkJICAgIHBoW2ldLnBfdHlwZSA9PSBQVF9QSERSCi0JCSAgICB8fCBwaFtpXS5wX3R5cGUgPT0gUFRfTUlQU19SRUdJTkZPKQorCQlzd2l0Y2ggKHBoW2ldLnBfdHlwZSkgeworCQljYXNlIFBUX05VTEw6CisJCWNhc2UgUFRfTk9URToKKwkJY2FzZSBQVF9QSERSOgorCQljYXNlIFBUX01JUFNfUkVHSU5GTzoKKwkJY2FzZSBQVF9NSVBTX0FCSUZMQUdTOgogCQkJY29udGludWU7Ci0JCS8qIFNlY3Rpb24gdHlwZXMgd2UgY2FuJ3QgaGFuZGxlLi4uICovCi0JCWVsc2UgaWYgKHBoW2ldLnBfdHlwZSAhPSBQVF9MT0FEKSB7CisKKwkJY2FzZSBQVF9MT0FEOgorCQkJLyogV3JpdGFibGUgKGRhdGEpIHNlZ21lbnQ/ICovCisJCQlpZiAocGhbaV0ucF9mbGFncyAmIFBGX1cpIHsKKwkJCQlzdHJ1Y3Qgc2VjdCBuZGF0YSwgbmJzczsKKworCQkJCW5kYXRhLnZhZGRyID0gcGhbaV0ucF92YWRkcjsKKwkJCQluZGF0YS5sZW4gPSBwaFtpXS5wX2ZpbGVzejsKKwkJCQluYnNzLnZhZGRyID0gcGhbaV0ucF92YWRkciArIHBoW2ldLnBfZmlsZXN6OworCQkJCW5ic3MubGVuID0gcGhbaV0ucF9tZW1zeiAtIHBoW2ldLnBfZmlsZXN6OworCisJCQkJY29tYmluZSgmZGF0YSwgJm5kYXRhLCAwKTsKKwkJCQljb21iaW5lKCZic3MsICZuYnNzLCAxKTsKKwkJCX0gZWxzZSB7CisJCQkJc3RydWN0IHNlY3QgbnR4dDsKKworCQkJCW50eHQudmFkZHIgPSBwaFtpXS5wX3ZhZGRyOworCQkJCW50eHQubGVuID0gcGhbaV0ucF9maWxlc3o7CisKKwkJCQljb21iaW5lKCZ0ZXh0LCAmbnR4dCwgMCk7CisJCQl9CisJCQkvKiBSZW1lbWJlciB0aGUgbG93ZXN0IHNlZ21lbnQgc3RhcnQgYWRkcmVzcy4gKi8KKwkJCWlmIChwaFtpXS5wX3ZhZGRyIDwgY3VyX3ZtYSkKKwkJCQljdXJfdm1hID0gcGhbaV0ucF92YWRkcjsKKwkJCWJyZWFrOworCisJCWRlZmF1bHQ6CisJCQkvKiBTZWN0aW9uIHR5cGVzIHdlIGNhbid0IGhhbmRsZS4uLiAqLwogCQkJZnByaW50ZihzdGRlcnIsCiAJCQkJIlByb2dyYW0gaGVhZGVyICVkIHR5cGUgJWQgY2FuJ3QgYmUgY29udmVydGVkLlxuIiwKIAkJCQlleC5lX3BobnVtLCBwaFtpXS5wX3R5cGUpOwogCQkJZXhpdCgxKTsKIAkJfQotCQkvKiBXcml0YWJsZSAoZGF0YSkgc2VnbWVudD8gKi8KLQkJaWYgKHBoW2ldLnBfZmxhZ3MgJiBQRl9XKSB7Ci0JCQlzdHJ1Y3Qgc2VjdCBuZGF0YSwgbmJzczsKLQotCQkJbmRhdGEudmFkZHIgPSBwaFtpXS5wX3ZhZGRyOwotCQkJbmRhdGEubGVuID0gcGhbaV0ucF9maWxlc3o7Ci0JCQluYnNzLnZhZGRyID0gcGhbaV0ucF92YWRkciArIHBoW2ldLnBfZmlsZXN6OwotCQkJbmJzcy5sZW4gPSBwaFtpXS5wX21lbXN6IC0gcGhbaV0ucF9maWxlc3o7Ci0KLQkJCWNvbWJpbmUoJmRhdGEsICZuZGF0YSwgMCk7Ci0JCQljb21iaW5lKCZic3MsICZuYnNzLCAxKTsKLQkJfSBlbHNlIHsKLQkJCXN0cnVjdCBzZWN0IG50eHQ7Ci0KLQkJCW50eHQudmFkZHIgPSBwaFtpXS5wX3ZhZGRyOwotCQkJbnR4dC5sZW4gPSBwaFtpXS5wX2ZpbGVzejsKLQotCQkJY29tYmluZSgmdGV4dCwgJm50eHQsIDApOwotCQl9Ci0JCS8qIFJlbWVtYmVyIHRoZSBsb3dlc3Qgc2VnbWVudCBzdGFydCBhZGRyZXNzLiAqLwotCQlpZiAocGhbaV0ucF92YWRkciA8IGN1cl92bWEpCi0JCQljdXJfdm1hID0gcGhbaV0ucF92YWRkcjsKIAl9CiAKIAkvKiBTZWN0aW9ucyBtdXN0IGJlIGluIG9yZGVyIHRvIGJlIGNvbnZlcnRlZC4uLiAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2Nhdml1bS1vY3Rlb24vc21wLmMgYi9hcmNoL21pcHMvY2F2aXVtLW9jdGVvbi9zbXAuYwppbmRleCBlY2Q5MDNkLi44YjFlZWZmIDEwMDY0NAotLS0gYS9hcmNoL21pcHMvY2F2aXVtLW9jdGVvbi9zbXAuYworKysgYi9hcmNoL21pcHMvY2F2aXVtLW9jdGVvbi9zbXAuYwpAQCAtMjQwLDkgKzI0MCw3IEBACiAKIAlzZXRfY3B1X29ubGluZShjcHUsIGZhbHNlKTsKIAljcHVfY2xlYXIoY3B1LCBjcHVfY2FsbGluX21hcCk7Ci0JbG9jYWxfaXJxX2Rpc2FibGUoKTsKIAlvY3Rlb25fZml4dXBfaXJxcygpOwotCWxvY2FsX2lycV9lbmFibGUoKTsKIAogCWZsdXNoX2NhY2hlX2FsbCgpOwogCWxvY2FsX2ZsdXNoX3RsYl9hbGwoKTsKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9jb25maWdzL21hbHRhX2RlZmNvbmZpZyBiL2FyY2gvbWlwcy9jb25maWdzL21hbHRhX2RlZmNvbmZpZwppbmRleCBmNTdiOTZkLi42MWE0NDYwIDEwMDY0NAotLS0gYS9hcmNoL21pcHMvY29uZmlncy9tYWx0YV9kZWZjb25maWcKKysrIGIvYXJjaC9taXBzL2NvbmZpZ3MvbWFsdGFfZGVmY29uZmlnCkBAIC0xMzIsNyArMTMyLDYgQEAKIENPTkZJR19JUF9ORl9NQVRDSF9UVEw9bQogQ09ORklHX0lQX05GX0ZJTFRFUj1tCiBDT05GSUdfSVBfTkZfVEFSR0VUX1JFSkVDVD1tCi1DT05GSUdfSVBfTkZfVEFSR0VUX1VMT0c9bQogQ09ORklHX0lQX05GX01BTkdMRT1tCiBDT05GSUdfSVBfTkZfVEFSR0VUX0NMVVNURVJJUD1tCiBDT05GSUdfSVBfTkZfVEFSR0VUX0VDTj1tCkBAIC0xNzUsNyArMTc0LDYgQEAKIENPTkZJR19CUklER0VfRUJUX1JFRElSRUNUPW0KIENPTkZJR19CUklER0VfRUJUX1NOQVQ9bQogQ09ORklHX0JSSURHRV9FQlRfTE9HPW0KLUNPTkZJR19CUklER0VfRUJUX1VMT0c9bQogQ09ORklHX0JSSURHRV9FQlRfTkZMT0c9bQogQ09ORklHX0lQX1NDVFA9bQogQ09ORklHX0JSSURHRT1tCkBAIC0yMjAsOCArMjE4LDYgQEAKIENPTkZJR19ORVRfQ0xTX0lORD15CiBDT05GSUdfQ0ZHODAyMTE9bQogQ09ORklHX01BQzgwMjExPW0KLUNPTkZJR19NQUM4MDIxMV9SQ19QSUQ9eQotQ09ORklHX01BQzgwMjExX1JDX0RFRkFVTFRfUElEPXkKIENPTkZJR19NQUM4MDIxMV9NRVNIPXkKIENPTkZJR19SRktJTEw9bQogQ09ORklHX1VFVkVOVF9IRUxQRVJfUEFUSD0iL3NiaW4vaG90cGx1ZyIKQEAgLTI0OCwxOSArMjQ0LDEzIEBACiBDT05GSUdfSURFPXkKIENPTkZJR19CTEtfREVWX0lERUNEPXkKIENPTkZJR19JREVfR0VORVJJQz15Ci1DT05GSUdfQkxLX0RFVl9HRU5FUklDPXkKLUNPTkZJR19CTEtfREVWX1BJSVg9eQotQ09ORklHX0JMS19ERVZfSVQ4MjEzPW0KLUNPTkZJR19CTEtfREVWX1RDODZDMDAxPW0KIENPTkZJR19SQUlEX0FUVFJTPW0KLUNPTkZJR19TQ1NJPW0KLUNPTkZJR19CTEtfREVWX1NEPW0KK0NPTkZJR19CTEtfREVWX1NEPXkKIENPTkZJR19DSFJfREVWX1NUPW0KIENPTkZJR19DSFJfREVWX09TU1Q9bQogQ09ORklHX0JMS19ERVZfU1I9bQogQ09ORklHX0JMS19ERVZfU1JfVkVORE9SPXkKIENPTkZJR19DSFJfREVWX1NHPW0KLUNPTkZJR19TQ1NJX01VTFRJX0xVTj15CiBDT05GSUdfU0NTSV9DT05TVEFOVFM9eQogQ09ORklHX1NDU0lfTE9HR0lORz15CiBDT05GSUdfU0NTSV9TQ0FOX0FTWU5DPXkKQEAgLTI3Myw2ICsyNjMsOCBAQAogQ09ORklHX1NDU0lfQUlDN1hYWD1tCiBDT05GSUdfQUlDN1hYWF9SRVNFVF9ERUxBWV9NUz0xNTAwMAogIyBDT05GSUdfQUlDN1hYWF9ERUJVR19FTkFCTEUgaXMgbm90IHNldAorQ09ORklHX0FUQT15CitDT05GSUdfQVRBX1BJSVg9eQogQ09ORklHX01EPXkKIENPTkZJR19CTEtfREVWX01EPW0KIENPTkZJR19NRF9MSU5FQVI9bQpAQCAtMzQwLDYgKzMzMiw3IEBACiBDT05GSUdfVUlPX0NJRj1tCiBDT05GSUdfRVhUMl9GUz15CiBDT05GSUdfRVhUM19GUz15CitDT05GSUdfRVhUNF9GUz15CiBDT05GSUdfUkVJU0VSRlNfRlM9bQogQ09ORklHX1JFSVNFUkZTX1BST0NfSU5GTz15CiBDT05GSUdfUkVJU0VSRlNfRlNfWEFUVFI9eQpAQCAtNDQxLDQgKzQzNCwzIEBACiBDT05GSUdfQ1JZUFRPX1RFQT1tCiBDT05GSUdfQ1JZUFRPX1RXT0ZJU0g9bQogIyBDT05GSUdfQ1JZUFRPX0FOU0lfQ1BSTkcgaXMgbm90IHNldAotQ09ORklHX0NSQzE2PW0KZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9mcHUuaCBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9mcHUuaAppbmRleCA5OTRkMjE5Li5hZmZlYmI3IDEwMDY0NAotLS0gYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vZnB1LmgKKysrIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL2ZwdS5oCkBAIC02NCw3ICs2NCw3IEBACiAJCQlyZXR1cm4gU0lHRlBFOwogCiAJCS8qIHNldCBGUkUgKi8KLQkJd3JpdGVfYzBfY29uZmlnNShyZWFkX2MwX2NvbmZpZzUoKSB8IE1JUFNfQ09ORjVfRlJFKTsKKwkJc2V0X2MwX2NvbmZpZzUoTUlQU19DT05GNV9GUkUpOwogCQlnb3RvIGZyX2NvbW1vbjsKIAogCWNhc2UgRlBVXzY0QklUOgpAQCAtNzQsOCArNzQsMTAgQEAKICNlbmRpZgogCQkvKiBmYWxsIHRocm91Z2ggKi8KIAljYXNlIEZQVV8zMkJJVDoKLQkJLyogY2xlYXIgRlJFICovCi0JCXdyaXRlX2MwX2NvbmZpZzUocmVhZF9jMF9jb25maWc1KCkgJiB+TUlQU19DT05GNV9GUkUpOworCQlpZiAoY3B1X2hhc19mcmUpIHsKKwkJCS8qIGNsZWFyIEZSRSAqLworCQkJY2xlYXJfYzBfY29uZmlnNShNSVBTX0NPTkY1X0ZSRSk7CisJCX0KIGZyX2NvbW1vbjoKIAkJLyogc2V0IENVMSAmIGNoYW5nZSBGUiBhcHByb3ByaWF0ZWx5ICovCiAJCWZyID0gKGludCltb2RlICYgRlBVX0ZSX01BU0s7CkBAIC0xODIsMjUgKzE4NCwzMiBAQAogCWludCByZXQgPSAwOwogCiAJaWYgKGNwdV9oYXNfZnB1KSB7CisJCXVuc2lnbmVkIGludCBjb25maWc1OworCiAJCXJldCA9IF9fb3duX2ZwdSgpOwotCQlpZiAoIXJldCkgewotCQkJdW5zaWduZWQgaW50IGNvbmZpZzUgPSByZWFkX2MwX2NvbmZpZzUoKTsKKwkJaWYgKHJldCkKKwkJCXJldHVybiByZXQ7CiAKLQkJCS8qCi0JCQkgKiBFbnN1cmUgRlJFIGlzIGNsZWFyIHdoaWxzdCBydW5uaW5nIF9pbml0X2ZwdSwgc2luY2UKLQkJCSAqIHNpbmdsZSBwcmVjaXNpb24gRlAgaW5zdHJ1Y3Rpb25zIGFyZSB1c2VkLiBJZiBGUkUKLQkJCSAqIHdhcyBzZXQgdGhlbiB3ZSdsbCBqdXN0IGVuZCB1cCBpbml0aWFsaXNpbmcgYWxsIDMyCi0JCQkgKiA2NGIgcmVnaXN0ZXJzLgotCQkJICovCi0JCQl3cml0ZV9jMF9jb25maWc1KGNvbmZpZzUgJiB+TUlQU19DT05GNV9GUkUpOwotCQkJZW5hYmxlX2ZwdV9oYXphcmQoKTsKLQorCQlpZiAoIWNwdV9oYXNfZnJlKSB7CiAJCQlfaW5pdF9mcHUoKTsKIAotCQkJLyogUmVzdG9yZSBGUkUgKi8KLQkJCXdyaXRlX2MwX2NvbmZpZzUoY29uZmlnNSk7Ci0JCQllbmFibGVfZnB1X2hhemFyZCgpOworCQkJcmV0dXJuIDA7CiAJCX0KKworCQkvKgorCQkgKiBFbnN1cmUgRlJFIGlzIGNsZWFyIHdoaWxzdCBydW5uaW5nIF9pbml0X2ZwdSwgc2luY2UKKwkJICogc2luZ2xlIHByZWNpc2lvbiBGUCBpbnN0cnVjdGlvbnMgYXJlIHVzZWQuIElmIEZSRQorCQkgKiB3YXMgc2V0IHRoZW4gd2UnbGwganVzdCBlbmQgdXAgaW5pdGlhbGlzaW5nIGFsbCAzMgorCQkgKiA2NGIgcmVnaXN0ZXJzLgorCQkgKi8KKwkJY29uZmlnNSA9IGNsZWFyX2MwX2NvbmZpZzUoTUlQU19DT05GNV9GUkUpOworCQllbmFibGVfZnB1X2hhemFyZCgpOworCisJCV9pbml0X2ZwdSgpOworCisJCS8qIFJlc3RvcmUgRlJFICovCisJCXdyaXRlX2MwX2NvbmZpZzUoY29uZmlnNSk7CisJCWVuYWJsZV9mcHVfaGF6YXJkKCk7CiAJfSBlbHNlCiAJCWZwdV9lbXVsYXRvcl9pbml0X2ZwdSgpOwogCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vZncvYXJjL2hpbnYuaCBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9mdy9hcmMvaGludi5oCmluZGV4IGY4ZDM3ZDEuLjlmYWM2NGEgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9mdy9hcmMvaGludi5oCisrKyBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9mdy9hcmMvaGludi5oCkBAIC0xMTksNyArMTE5LDcgQEAKICNkZWZpbmUgU0dJX0FSQ1NfUkVWCTEwCQkJLyogcmV2IC4xMCwgMy8wNC85MiAqLwogI2VuZGlmCiAKLXR5cGVkZWYgc3RydWN0IGNvbXBvbmVudCB7Cit0eXBlZGVmIHN0cnVjdCB7CiAJQ09ORklHQ0xBU1MJQ2xhc3M7CiAJQ09ORklHVFlQRQlUeXBlOwogCUlERU5USUZJRVJGTEFHCUZsYWdzOwpAQCAtMTQwLDcgKzE0MCw3IEBACiB9OwogCiAvKiBTeXN0ZW0gSUQgKi8KLXR5cGVkZWYgc3RydWN0IHN5c3RlbWlkIHsKK3R5cGVkZWYgc3RydWN0IHsKIAlDSEFSIFZlbmRvcklkWzhdOwogCUNIQVIgUHJvZHVjdElkWzhdOwogfSBTWVNURU1JRDsKQEAgLTE2Niw3ICsxNjYsNyBAQAogI2VuZGlmCS8qIF9OVF9QUk9NICovCiB9IE1FTU9SWVRZUEU7CiAKLXR5cGVkZWYgc3RydWN0IG1lbW9yeWRlc2NyaXB0b3IgewordHlwZWRlZiBzdHJ1Y3QgewogCU1FTU9SWVRZUEUJVHlwZTsKIAlMT05HCQlCYXNlUGFnZTsKIAlMT05HCQlQYWdlQ291bnQ7CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vbWlwcy1jbS5oIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL21pcHMtY20uaAppbmRleCBiOTVhODI3Li41OWMwOTAxIDEwMDY0NAotLS0gYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vbWlwcy1jbS5oCisrKyBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9taXBzLWNtLmgKQEAgLTg5LDkgKzg5LDkgQEAKIAogLyogTWFjcm9zIHRvIGVhc2UgdGhlIGNyZWF0aW9uIG9mIHJlZ2lzdGVyIGFjY2VzcyBmdW5jdGlvbnMgKi8KICNkZWZpbmUgQlVJTERfQ01fUl8obmFtZSwgb2ZmKQkJCQkJXAotc3RhdGljIGlubGluZSB1MzIgKmFkZHJfZ2NyXyMjbmFtZSh2b2lkKQkJCVwKK3N0YXRpYyBpbmxpbmUgdTMyIF9faW9tZW0gKmFkZHJfZ2NyXyMjbmFtZSh2b2lkKQkJXAogewkJCQkJCQkJXAotCXJldHVybiAodTMyICopKG1pcHNfY21fYmFzZSArIChvZmYpKTsJCQlcCisJcmV0dXJuICh1MzIgX19pb21lbSAqKShtaXBzX2NtX2Jhc2UgKyAob2ZmKSk7CQlcCiB9CQkJCQkJCQlcCiAJCQkJCQkJCVwKIHN0YXRpYyBpbmxpbmUgdTMyIHJlYWRfZ2NyXyMjbmFtZSh2b2lkKQkJCQlcCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vbWlwc3JlZ3MuaCBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9taXBzcmVncy5oCmluZGV4IDVlNGFlZjMuLjViNzIwZDggMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9taXBzcmVncy5oCisrKyBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9taXBzcmVncy5oCkBAIC0xMzg2LDEyICsxMzg2LDI3IEBACiAJX19yZXM7CQkJCQkJCQlcCiB9KQogCisjZGVmaW5lIF93cml0ZV8zMmJpdF9jcDFfcmVnaXN0ZXIoZGVzdCwgdmFsLCBnYXNfaGFyZGZsb2F0KQkJXAorZG8gewkJCQkJCQkJCVwKKwlfX2FzbV9fIF9fdm9sYXRpbGVfXygJCQkJCQlcCisJIgkuc2V0CXB1c2gJCQkJCVxuIglcCisJIgkuc2V0CXJlb3JkZXIJCQkJCVxuIglcCisJIgkiU1RSKGdhc19oYXJkZmxvYXQpIgkJCQlcbiIJXAorCSIJY3RjMQklMCwiU1RSKGRlc3QpIgkJCQlcbiIJXAorCSIJLnNldAlwb3AJCQkJCVxuIglcCisJOiA6ICJyIiAodmFsKSk7CQkJCQkJCVwKK30gd2hpbGUgKDApCisKICNpZmRlZiBHQVNfSEFTX1NFVF9IQVJERkxPQVQKICNkZWZpbmUgcmVhZF8zMmJpdF9jcDFfcmVnaXN0ZXIoc291cmNlKQkJCQkJXAogCV9yZWFkXzMyYml0X2NwMV9yZWdpc3Rlcihzb3VyY2UsIC5zZXQgaGFyZGZsb2F0KQorI2RlZmluZSB3cml0ZV8zMmJpdF9jcDFfcmVnaXN0ZXIoZGVzdCwgdmFsKQkJCQlcCisJX3dyaXRlXzMyYml0X2NwMV9yZWdpc3RlcihkZXN0LCB2YWwsIC5zZXQgaGFyZGZsb2F0KQogI2Vsc2UKICNkZWZpbmUgcmVhZF8zMmJpdF9jcDFfcmVnaXN0ZXIoc291cmNlKQkJCQkJXAogCV9yZWFkXzMyYml0X2NwMV9yZWdpc3Rlcihzb3VyY2UsICkKKyNkZWZpbmUgd3JpdGVfMzJiaXRfY3AxX3JlZ2lzdGVyKGRlc3QsIHZhbCkJCQkJXAorCV93cml0ZV8zMmJpdF9jcDFfcmVnaXN0ZXIoZGVzdCwgdmFsLCApCiAjZW5kaWYKIAogI2lmZGVmIEhBVkVfQVNfRFNQCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vc3lzY2FsbC5oIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL3N5c2NhbGwuaAppbmRleCBiYjc5NjM3Li42NDk5ZDkzIDEwMDY0NAotLS0gYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vc3lzY2FsbC5oCisrKyBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9zeXNjYWxsLmgKQEAgLTI5LDEzICsyOSw3IEBACiBzdGF0aWMgaW5saW5lIGxvbmcgc3lzY2FsbF9nZXRfbnIoc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrLAogCQkJCSAgc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCiB7Ci0JLyogTzMyIEFCSSBzeXNjYWxsKCkgLSBFaXRoZXIgNjQtYml0IHdpdGggTzMyIG9yIDMyLWJpdCAqLwotCWlmICgoY29uZmlnX2VuYWJsZWQoQ09ORklHXzMyQklUKSB8fAotCSAgICB0ZXN0X3Rza190aHJlYWRfZmxhZyh0YXNrLCBUSUZfMzJCSVRfUkVHUykpICYmCi0JICAgIChyZWdzLT5yZWdzWzJdID09IF9fTlJfc3lzY2FsbCkpCi0JCXJldHVybiByZWdzLT5yZWdzWzRdOwotCWVsc2UKLQkJcmV0dXJuIHJlZ3MtPnJlZ3NbMl07CisJcmV0dXJuIGN1cnJlbnRfdGhyZWFkX2luZm8oKS0+c3lzY2FsbDsKIH0KIAogc3RhdGljIGlubGluZSB1bnNpZ25lZCBsb25nIG1pcHNfZ2V0X3N5c2NhbGxfYXJnKHVuc2lnbmVkIGxvbmcgKmFyZywKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS90aHJlYWRfaW5mby5oIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL3RocmVhZF9pbmZvLmgKaW5kZXggOTllZWE1OS4uZTQ0NDBmOSAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL3RocmVhZF9pbmZvLmgKKysrIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL3RocmVhZF9pbmZvLmgKQEAgLTM2LDYgKzM2LDcgQEAKIAkJCQkJCSAqLwogCXN0cnVjdCByZXN0YXJ0X2Jsb2NrCXJlc3RhcnRfYmxvY2s7CiAJc3RydWN0IHB0X3JlZ3MJCSpyZWdzOworCWxvbmcJCQlzeXNjYWxsOwkvKiBzeXNjYWxsIG51bWJlciAqLwogfTsKIAogLyoKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9pbmNsdWRlL3VhcGkvYXNtL3VuaXN0ZC5oIGIvYXJjaC9taXBzL2luY2x1ZGUvdWFwaS9hc20vdW5pc3RkLmgKaW5kZXggZDAwMWJiMS4uYzAzMDg4ZiAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2luY2x1ZGUvdWFwaS9hc20vdW5pc3RkLmgKKysrIGIvYXJjaC9taXBzL2luY2x1ZGUvdWFwaS9hc20vdW5pc3RkLmgKQEAgLTM3NiwxNiArMzc2LDE3IEBACiAjZGVmaW5lIF9fTlJfZ2V0cmFuZG9tCQkJKF9fTlJfTGludXggKyAzNTMpCiAjZGVmaW5lIF9fTlJfbWVtZmRfY3JlYXRlCQkoX19OUl9MaW51eCArIDM1NCkKICNkZWZpbmUgX19OUl9icGYJCQkoX19OUl9MaW51eCArIDM1NSkKKyNkZWZpbmUgX19OUl9leGVjdmVhdAkJCShfX05SX0xpbnV4ICsgMzU2KQogCiAvKgogICogT2Zmc2V0IG9mIHRoZSBsYXN0IExpbnV4IG8zMiBmbGF2b3VyZWQgc3lzY2FsbAogICovCi0jZGVmaW5lIF9fTlJfTGludXhfc3lzY2FsbHMJCTM1NQorI2RlZmluZSBfX05SX0xpbnV4X3N5c2NhbGxzCQkzNTYKIAogI2VuZGlmIC8qIF9NSVBTX1NJTSA9PSBfTUlQU19TSU1fQUJJMzIgKi8KIAogI2RlZmluZSBfX05SX08zMl9MaW51eAkJCTQwMDAKLSNkZWZpbmUgX19OUl9PMzJfTGludXhfc3lzY2FsbHMJCTM1NQorI2RlZmluZSBfX05SX08zMl9MaW51eF9zeXNjYWxscwkJMzU2CiAKICNpZiBfTUlQU19TSU0gPT0gX01JUFNfU0lNX0FCSTY0CiAKQEAgLTcwOSwxNiArNzEwLDE3IEBACiAjZGVmaW5lIF9fTlJfZ2V0cmFuZG9tCQkJKF9fTlJfTGludXggKyAzMTMpCiAjZGVmaW5lIF9fTlJfbWVtZmRfY3JlYXRlCQkoX19OUl9MaW51eCArIDMxNCkKICNkZWZpbmUgX19OUl9icGYJCQkoX19OUl9MaW51eCArIDMxNSkKKyNkZWZpbmUgX19OUl9leGVjdmVhdAkJCShfX05SX0xpbnV4ICsgMzE2KQogCiAvKgogICogT2Zmc2V0IG9mIHRoZSBsYXN0IExpbnV4IDY0LWJpdCBmbGF2b3VyZWQgc3lzY2FsbAogICovCi0jZGVmaW5lIF9fTlJfTGludXhfc3lzY2FsbHMJCTMxNQorI2RlZmluZSBfX05SX0xpbnV4X3N5c2NhbGxzCQkzMTYKIAogI2VuZGlmIC8qIF9NSVBTX1NJTSA9PSBfTUlQU19TSU1fQUJJNjQgKi8KIAogI2RlZmluZSBfX05SXzY0X0xpbnV4CQkJNTAwMAotI2RlZmluZSBfX05SXzY0X0xpbnV4X3N5c2NhbGxzCQkzMTUKKyNkZWZpbmUgX19OUl82NF9MaW51eF9zeXNjYWxscwkJMzE2CiAKICNpZiBfTUlQU19TSU0gPT0gX01JUFNfU0lNX05BQkkzMgogCkBAIC0xMDQ2LDE1ICsxMDQ4LDE2IEBACiAjZGVmaW5lIF9fTlJfZ2V0cmFuZG9tCQkJKF9fTlJfTGludXggKyAzMTcpCiAjZGVmaW5lIF9fTlJfbWVtZmRfY3JlYXRlCQkoX19OUl9MaW51eCArIDMxOCkKICNkZWZpbmUgX19OUl9icGYJCQkoX19OUl9MaW51eCArIDMxOSkKKyNkZWZpbmUgX19OUl9leGVjdmVhdAkJCShfX05SX0xpbnV4ICsgMzIwKQogCiAvKgogICogT2Zmc2V0IG9mIHRoZSBsYXN0IE4zMiBmbGF2b3VyZWQgc3lzY2FsbAogICovCi0jZGVmaW5lIF9fTlJfTGludXhfc3lzY2FsbHMJCTMxOQorI2RlZmluZSBfX05SX0xpbnV4X3N5c2NhbGxzCQkzMjAKIAogI2VuZGlmIC8qIF9NSVBTX1NJTSA9PSBfTUlQU19TSU1fTkFCSTMyICovCiAKICNkZWZpbmUgX19OUl9OMzJfTGludXgJCQk2MDAwCi0jZGVmaW5lIF9fTlJfTjMyX0xpbnV4X3N5c2NhbGxzCQkzMTkKKyNkZWZpbmUgX19OUl9OMzJfTGludXhfc3lzY2FsbHMJCTMyMAogCiAjZW5kaWYgLyogX1VBUElfQVNNX1VOSVNURF9IICovCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvano0NzQwL2lycS5jIGIvYXJjaC9taXBzL2p6NDc0MC9pcnEuYwppbmRleCAyNTMxZGExLi45NzIwNmIzIDEwMDY0NAotLS0gYS9hcmNoL21pcHMvano0NzQwL2lycS5jCisrKyBiL2FyY2gvbWlwcy9qejQ3NDAvaXJxLmMKQEAgLTMwLDYgKzMwLDkgQEAKICNpbmNsdWRlIDxhc20vaXJxX2NwdS5oPgogCiAjaW5jbHVkZSA8YXNtL21hY2gtano0NzQwL2Jhc2UuaD4KKyNpbmNsdWRlIDxhc20vbWFjaC1qejQ3NDAvaXJxLmg+CisKKyNpbmNsdWRlICJpcnEuaCIKIAogc3RhdGljIHZvaWQgX19pb21lbSAqanpfaW50Y19iYXNlOwogCmRpZmYgLS1naXQgYS9hcmNoL21pcHMva2VybmVsL2VsZi5jIGIvYXJjaC9taXBzL2tlcm5lbC9lbGYuYwppbmRleCBjOTJiMTVkLi5hNWI1YjU2IDEwMDY0NAotLS0gYS9hcmNoL21pcHMva2VybmVsL2VsZi5jCisrKyBiL2FyY2gvbWlwcy9rZXJuZWwvZWxmLmMKQEAgLTE5LDggKzE5LDggQEAKIGludCBhcmNoX2VsZl9wdF9wcm9jKHZvaWQgKl9laGRyLCB2b2lkICpfcGhkciwgc3RydWN0IGZpbGUgKmVsZiwKIAkJICAgICBib29sIGlzX2ludGVycCwgc3RydWN0IGFyY2hfZWxmX3N0YXRlICpzdGF0ZSkKIHsKLQlzdHJ1Y3QgZWxmaGRyICplaGRyID0gX2VoZHI7Ci0Jc3RydWN0IGVsZl9waGRyICpwaGRyID0gX3BoZHI7CisJc3RydWN0IGVsZjMyX2hkciAqZWhkciA9IF9laGRyOworCXN0cnVjdCBlbGYzMl9waGRyICpwaGRyID0gX3BoZHI7CiAJc3RydWN0IG1pcHNfZWxmX2FiaWZsYWdzX3YwIGFiaWZsYWdzOwogCWludCByZXQ7CiAKQEAgLTQ4LDcgKzQ4LDcgQEAKIAlyZXR1cm4gMDsKIH0KIAotc3RhdGljIGlubGluZSB1bnNpZ25lZCBnZXRfZnBfYWJpKHN0cnVjdCBlbGZoZHIgKmVoZHIsIGludCBpbl9hYmkpCitzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGdldF9mcF9hYmkoc3RydWN0IGVsZjMyX2hkciAqZWhkciwgaW50IGluX2FiaSkKIHsKIAkvKiBJZiB0aGUgQUJJIHJlcXVpcmVtZW50IGlzIHByb3ZpZGVkLCBzaW1wbHkgcmV0dXJuIHRoYXQgKi8KIAlpZiAoaW5fYWJpICE9IC0xKQpAQCAtNjUsNyArNjUsNyBAQAogaW50IGFyY2hfY2hlY2tfZWxmKHZvaWQgKl9laGRyLCBib29sIGhhc19pbnRlcnByZXRlciwKIAkJICAgc3RydWN0IGFyY2hfZWxmX3N0YXRlICpzdGF0ZSkKIHsKLQlzdHJ1Y3QgZWxmaGRyICplaGRyID0gX2VoZHI7CisJc3RydWN0IGVsZjMyX2hkciAqZWhkciA9IF9laGRyOwogCXVuc2lnbmVkIGZwX2FiaSwgaW50ZXJwX2ZwX2FiaSwgYWJpMCwgYWJpMTsKIAogCS8qIElnbm9yZSBub24tTzMyIGJpbmFyaWVzICovCmRpZmYgLS1naXQgYS9hcmNoL21pcHMva2VybmVsL2lycV9jcHUuYyBiL2FyY2gvbWlwcy9rZXJuZWwvaXJxX2NwdS5jCmluZGV4IDU5MGMyYzkuLjZlYjdhM2YgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9rZXJuZWwvaXJxX2NwdS5jCisrKyBiL2FyY2gvbWlwcy9rZXJuZWwvaXJxX2NwdS5jCkBAIC01Nyw2ICs1Nyw4IEBACiAJLmlycV9tYXNrX2Fjawk9IG1hc2tfbWlwc19pcnEsCiAJLmlycV91bm1hc2sJPSB1bm1hc2tfbWlwc19pcnEsCiAJLmlycV9lb2kJPSB1bm1hc2tfbWlwc19pcnEsCisJLmlycV9kaXNhYmxlCT0gbWFza19taXBzX2lycSwKKwkuaXJxX2VuYWJsZQk9IHVubWFza19taXBzX2lycSwKIH07CiAKIC8qCkBAIC05Myw2ICs5NSw4IEBACiAJLmlycV9tYXNrX2Fjawk9IG1pcHNfbXRfY3B1X2lycV9hY2ssCiAJLmlycV91bm1hc2sJPSB1bm1hc2tfbWlwc19pcnEsCiAJLmlycV9lb2kJPSB1bm1hc2tfbWlwc19pcnEsCisJLmlycV9kaXNhYmxlCT0gbWFza19taXBzX2lycSwKKwkuaXJxX2VuYWJsZQk9IHVubWFza19taXBzX2lycSwKIH07CiAKIGFzbWxpbmthZ2Ugdm9pZCBfX3dlYWsgcGxhdF9pcnFfZGlzcGF0Y2godm9pZCkKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9rZXJuZWwvcHJvY2Vzcy5jIGIvYXJjaC9taXBzL2tlcm5lbC9wcm9jZXNzLmMKaW5kZXggZWI3NjQzNC4uODViZmY1ZCAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2tlcm5lbC9wcm9jZXNzLmMKKysrIGIvYXJjaC9taXBzL2tlcm5lbC9wcm9jZXNzLmMKQEAgLTgyLDYgKzgyLDMwIEBACiB7CiB9CiAKK2ludCBhcmNoX2R1cF90YXNrX3N0cnVjdChzdHJ1Y3QgdGFza19zdHJ1Y3QgKmRzdCwgc3RydWN0IHRhc2tfc3RydWN0ICpzcmMpCit7CisJLyoKKwkgKiBTYXZlIGFueSBwcm9jZXNzIHN0YXRlIHdoaWNoIGlzIGxpdmUgaW4gaGFyZHdhcmUgcmVnaXN0ZXJzIHRvIHRoZQorCSAqIHBhcmVudCBjb250ZXh0IHByaW9yIHRvIGR1cGxpY2F0aW9uLiBUaGlzIHByZXZlbnRzIHRoZSBuZXcgY2hpbGQKKwkgKiBzdGF0ZSBiZWNvbWluZyBzdGFsZSBpZiB0aGUgcGFyZW50IGlzIHByZWVtcHRlZCBiZWZvcmUgY29weV90aHJlYWQoKQorCSAqIGdldHMgYSBjaGFuY2UgdG8gc2F2ZSB0aGUgcGFyZW50J3MgbGl2ZSBoYXJkd2FyZSByZWdpc3RlcnMgdG8gdGhlCisJICogY2hpbGQgY29udGV4dC4KKwkgKi8KKwlwcmVlbXB0X2Rpc2FibGUoKTsKKworCWlmIChpc19tc2FfZW5hYmxlZCgpKQorCQlzYXZlX21zYShjdXJyZW50KTsKKwllbHNlIGlmIChpc19mcHVfb3duZXIoKSkKKwkJX3NhdmVfZnAoY3VycmVudCk7CisKKwlzYXZlX2RzcChjdXJyZW50KTsKKworCXByZWVtcHRfZW5hYmxlKCk7CisKKwkqZHN0ID0gKnNyYzsKKwlyZXR1cm4gMDsKK30KKwogaW50IGNvcHlfdGhyZWFkKHVuc2lnbmVkIGxvbmcgY2xvbmVfZmxhZ3MsIHVuc2lnbmVkIGxvbmcgdXNwLAogCXVuc2lnbmVkIGxvbmcgYXJnLCBzdHJ1Y3QgdGFza19zdHJ1Y3QgKnApCiB7CkBAIC05MiwxOCArMTE2LDYgQEAKIAogCWNoaWxka3NwID0gKHVuc2lnbmVkIGxvbmcpdGFza19zdGFja19wYWdlKHApICsgVEhSRUFEX1NJWkUgLSAzMjsKIAotCXByZWVtcHRfZGlzYWJsZSgpOwotCi0JaWYgKGlzX21zYV9lbmFibGVkKCkpCi0JCXNhdmVfbXNhKHApOwotCWVsc2UgaWYgKGlzX2ZwdV9vd25lcigpKQotCQlzYXZlX2ZwKHApOwotCi0JaWYgKGNwdV9oYXNfZHNwKQotCQlzYXZlX2RzcChwKTsKLQotCXByZWVtcHRfZW5hYmxlKCk7Ci0KIAkvKiBzZXQgdXAgbmV3IFRTUy4gKi8KIAljaGlsZHJlZ3MgPSAoc3RydWN0IHB0X3JlZ3MgKikgY2hpbGRrc3AgLSAxOwogCS8qICBQdXQgdGhlIHN0YWNrIGFmdGVyIHRoZSBzdHJ1Y3QgcHRfcmVncy4gICovCmRpZmYgLS1naXQgYS9hcmNoL21pcHMva2VybmVsL3B0cmFjZS5jIGIvYXJjaC9taXBzL2tlcm5lbC9wdHJhY2UuYwppbmRleCA5ZDE0ODdkLi41MTA0NTI4IDEwMDY0NAotLS0gYS9hcmNoL21pcHMva2VybmVsL3B0cmFjZS5jCisrKyBiL2FyY2gvbWlwcy9rZXJuZWwvcHRyYWNlLmMKQEAgLTc3MCw2ICs3NzAsOCBAQAogCWxvbmcgcmV0ID0gMDsKIAl1c2VyX2V4aXQoKTsKIAorCWN1cnJlbnRfdGhyZWFkX2luZm8oKS0+c3lzY2FsbCA9IHN5c2NhbGw7CisKIAlpZiAoc2VjdXJlX2NvbXB1dGluZygpID09IC0xKQogCQlyZXR1cm4gLTE7CiAKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9rZXJuZWwvc2NhbGwzMi1vMzIuUyBiL2FyY2gvbWlwcy9rZXJuZWwvc2NhbGwzMi1vMzIuUwppbmRleCAwMGNhZDEwLi42ZThkZTgwIDEwMDY0NAotLS0gYS9hcmNoL21pcHMva2VybmVsL3NjYWxsMzItbzMyLlMKKysrIGIvYXJjaC9taXBzL2tlcm5lbC9zY2FsbDMyLW8zMi5TCkBAIC0xODEsNiArMTgxLDcgQEAKIAlzbGwJdDEsIHQwLCAyCiAJYmVxegl2MCwgZWludmFsCiAJbHcJdDIsIHN5c19jYWxsX3RhYmxlKHQxKQkJIyBzeXNjYWxsIHJvdXRpbmUKKwlzdwlhMCwgUFRfUjIoc3ApCQkJIyBjYWxsIHJvdXRpbmUgZGlyZWN0bHkgb24gcmVzdGFydAogCiAJLyogU29tZSBzeXNjYWxscyBsaWtlIGV4ZWN2ZSBnZXQgdGhlaXIgYXJndW1lbnRzIGZyb20gc3RydWN0IHB0X3JlZ3MKIAkgICBhbmQgY2xhaW0gemVybyBhcmd1bWVudHMgaW4gdGhlIHN5c2NhbGwgdGFibGUuIFRodXMgd2UgaGF2ZSB0bwpAQCAtNTgwLDMgKzU4MSw0IEBACiAJUFRSCXN5c19nZXRyYW5kb20KIAlQVFIJc3lzX21lbWZkX2NyZWF0ZQogCVBUUglzeXNfYnBmCQkJCS8qIDQzNTUgKi8KKwlQVFIJc3lzX2V4ZWN2ZWF0CmRpZmYgLS1naXQgYS9hcmNoL21pcHMva2VybmVsL3NjYWxsNjQtNjQuUyBiL2FyY2gvbWlwcy9rZXJuZWwvc2NhbGw2NC02NC5TCmluZGV4IDUyNTE1NjUuLmFkNGQ0NDYzIDEwMDY0NAotLS0gYS9hcmNoL21pcHMva2VybmVsL3NjYWxsNjQtNjQuUworKysgYi9hcmNoL21pcHMva2VybmVsL3NjYWxsNjQtNjQuUwpAQCAtNDM1LDQgKzQzNSw1IEBACiAJUFRSCXN5c19nZXRyYW5kb20KIAlQVFIJc3lzX21lbWZkX2NyZWF0ZQogCVBUUglzeXNfYnBmCQkJCS8qIDUzMTUgKi8KKwlQVFIJc3lzX2V4ZWN2ZWF0CiAJLnNpemUJc3lzX2NhbGxfdGFibGUsLi1zeXNfY2FsbF90YWJsZQpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2tlcm5lbC9zY2FsbDY0LW4zMi5TIGIvYXJjaC9taXBzL2tlcm5lbC9zY2FsbDY0LW4zMi5TCmluZGV4IDc3ZTc0MzkuLjQ0NmNjNjUgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9rZXJuZWwvc2NhbGw2NC1uMzIuUworKysgYi9hcmNoL21pcHMva2VybmVsL3NjYWxsNjQtbjMyLlMKQEAgLTQyOCw0ICs0MjgsNSBAQAogCVBUUglzeXNfZ2V0cmFuZG9tCiAJUFRSCXN5c19tZW1mZF9jcmVhdGUKIAlQVFIJc3lzX2JwZgorCVBUUgljb21wYXRfc3lzX2V4ZWN2ZWF0CQkvKiA2MzIwICovCiAJLnNpemUJc3lzbjMyX2NhbGxfdGFibGUsLi1zeXNuMzJfY2FsbF90YWJsZQpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2tlcm5lbC9zY2FsbDY0LW8zMi5TIGIvYXJjaC9taXBzL2tlcm5lbC9zY2FsbDY0LW8zMi5TCmluZGV4IDZmOGRiOWYuLmQwN2IyMTAgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9rZXJuZWwvc2NhbGw2NC1vMzIuUworKysgYi9hcmNoL21pcHMva2VybmVsL3NjYWxsNjQtbzMyLlMKQEAgLTE4Niw2ICsxODYsNyBAQAogCWRzbGwJdDEsIHQwLCAzCiAJYmVxegl2MCwgZWludmFsCiAJbGQJdDIsIHN5czMyX2NhbGxfdGFibGUodDEpCQkjIHN5c2NhbGwgcm91dGluZQorCXNkCWEwLCBQVF9SMihzcCkJCSMgY2FsbCByb3V0aW5lIGRpcmVjdGx5IG9uIHJlc3RhcnQKIAogCW1vdmUJYTAsIGExCQkJIyBzaGlmdCBhcmd1bWVudCByZWdpc3RlcnMKIAltb3ZlCWExLCBhMgpAQCAtNTY1LDQgKzU2Niw1IEBACiAJUFRSCXN5c19nZXRyYW5kb20KIAlQVFIJc3lzX21lbWZkX2NyZWF0ZQogCVBUUglzeXNfYnBmCQkJCS8qIDQzNTUgKi8KKwlQVFIJY29tcGF0X3N5c19leGVjdmVhdAogCS5zaXplCXN5czMyX2NhbGxfdGFibGUsLi1zeXMzMl9jYWxsX3RhYmxlCmRpZmYgLS1naXQgYS9hcmNoL21pcHMva2VybmVsL3NtcC1jbXAuYyBiL2FyY2gvbWlwcy9rZXJuZWwvc21wLWNtcC5jCmluZGV4IDFlMGE5M2MuLmUzNmE4NTkgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9rZXJuZWwvc21wLWNtcC5jCisrKyBiL2FyY2gvbWlwcy9rZXJuZWwvc21wLWNtcC5jCkBAIC00NCw4ICs0NCw4IEBACiAJc3RydWN0IGNwdWluZm9fbWlwcyAqYyBfX21heWJlX3VudXNlZCA9ICZjdXJyZW50X2NwdV9kYXRhOwogCiAJLyogQXNzdW1lIEdJQyBpcyBwcmVzZW50ICovCi0JY2hhbmdlX2MwX3N0YXR1cyhTVDBfSU0sIFNUQVRVU0ZfSVAzIHwgU1RBVFVTRl9JUDQgfCBTVEFUVVNGX0lQNiB8Ci0JCQkJIFNUQVRVU0ZfSVA3KTsKKwljaGFuZ2VfYzBfc3RhdHVzKFNUMF9JTSwgU1RBVFVTRl9JUDIgfCBTVEFUVVNGX0lQMyB8IFNUQVRVU0ZfSVA0IHwKKwkJCQkgU1RBVFVTRl9JUDUgfCBTVEFUVVNGX0lQNiB8IFNUQVRVU0ZfSVA3KTsKIAogCS8qIEVuYWJsZSBwZXItY3B1IGludGVycnVwdHM6IHBsYXRmb3JtIHNwZWNpZmljICovCiAKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9rZXJuZWwvc21wLW10LmMgYi9hcmNoL21pcHMva2VybmVsL3NtcC1tdC5jCmluZGV4IGFkODY5NTEuLjE3ZWE3MDUgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9rZXJuZWwvc21wLW10LmMKKysrIGIvYXJjaC9taXBzL2tlcm5lbC9zbXAtbXQuYwpAQCAtMTYxLDcgKzE2MSw4IEBACiAjaWZkZWYgQ09ORklHX01JUFNfR0lDCiAJLyogVGhpcyBpcyBNYWx0YSBzcGVjaWZpYzogSVBJLHBlcmZvcm1hbmNlIGFuZCB0aW1lciBpbnRlcnJ1cHRzICovCiAJaWYgKGdpY19wcmVzZW50KQotCQljaGFuZ2VfYzBfc3RhdHVzKFNUMF9JTSwgU1RBVFVTRl9JUDMgfCBTVEFUVVNGX0lQNCB8CisJCWNoYW5nZV9jMF9zdGF0dXMoU1QwX0lNLCBTVEFUVVNGX0lQMiB8IFNUQVRVU0ZfSVAzIHwKKwkJCQkJIFNUQVRVU0ZfSVA0IHwgU1RBVFVTRl9JUDUgfAogCQkJCQkgU1RBVFVTRl9JUDYgfCBTVEFUVVNGX0lQNyk7CiAJZWxzZQogI2VuZGlmCmRpZmYgLS1naXQgYS9hcmNoL21pcHMva2VybmVsL3NtcC5jIGIvYXJjaC9taXBzL2tlcm5lbC9zbXAuYwppbmRleCBjOTRjNGU5Li4xYzBkOGM1IDEwMDY0NAotLS0gYS9hcmNoL21pcHMva2VybmVsL3NtcC5jCisrKyBiL2FyY2gvbWlwcy9rZXJuZWwvc21wLmMKQEAgLTEyMywxMCArMTIzLDEwIEBACiAJdW5zaWduZWQgaW50IGNwdTsKIAogCWNwdV9wcm9iZSgpOwotCWNwdV9yZXBvcnQoKTsKIAlwZXJfY3B1X3RyYXBfaW5pdChmYWxzZSk7CiAJbWlwc19jbG9ja2V2ZW50X2luaXQoKTsKIAltcF9vcHMtPmluaXRfc2Vjb25kYXJ5KCk7CisJY3B1X3JlcG9ydCgpOwogCiAJLyoKIAkgKiBYWFggcGFyaXR5IHByb3RlY3Rpb24gc2hvdWxkIGJlIGZvbGRlZCBpbiBoZXJlIHdoZW4gaXQncyBjb252ZXJ0ZWQKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9rZXJuZWwvdHJhcHMuYyBiL2FyY2gvbWlwcy9rZXJuZWwvdHJhcHMuYwppbmRleCBhZDNkMjAzLi5jM2I0MWUyIDEwMDY0NAotLS0gYS9hcmNoL21pcHMva2VybmVsL3RyYXBzLmMKKysrIGIvYXJjaC9taXBzL2tlcm5lbC90cmFwcy5jCkBAIC0xMjMxLDcgKzEyMzEsOCBAQAogCiAJCS8qIFJlc3RvcmUgdGhlIHNjYWxhciBGUCBjb250cm9sICYgc3RhdHVzIHJlZ2lzdGVyICovCiAJCWlmICghd2FzX2ZwdV9vd25lcikKLQkJCWFzbSB2b2xhdGlsZSgiY3RjMSAlMCwgJDMxIiA6IDogInIiKGN1cnJlbnQtPnRocmVhZC5mcHUuZmNyMzEpKTsKKwkJCXdyaXRlXzMyYml0X2NwMV9yZWdpc3RlcihDUDFfU1RBVFVTLAorCQkJCQkJIGN1cnJlbnQtPnRocmVhZC5mcHUuZmNyMzEpOwogCX0KIAogb3V0OgpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL21tL2ZhdWx0LmMgYi9hcmNoL21pcHMvbW0vZmF1bHQuYwppbmRleCBiZWNjNDJiLi43MGFiNWQ2IDEwMDY0NAotLS0gYS9hcmNoL21pcHMvbW0vZmF1bHQuYworKysgYi9hcmNoL21pcHMvbW0vZmF1bHQuYwpAQCAtMTU4LDYgKzE1OCw4IEBACiAJaWYgKHVubGlrZWx5KGZhdWx0ICYgVk1fRkFVTFRfRVJST1IpKSB7CiAJCWlmIChmYXVsdCAmIFZNX0ZBVUxUX09PTSkKIAkJCWdvdG8gb3V0X29mX21lbW9yeTsKKwkJZWxzZSBpZiAoZmF1bHQgJiBWTV9GQVVMVF9TSUdTRUdWKQorCQkJZ290byBiYWRfYXJlYTsKIAkJZWxzZSBpZiAoZmF1bHQgJiBWTV9GQVVMVF9TSUdCVVMpCiAJCQlnb3RvIGRvX3NpZ2J1czsKIAkJQlVHKCk7CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvbW0vdGxiLXI0ay5jIGIvYXJjaC9taXBzL21tL3RsYi1yNGsuYwppbmRleCBlOTBiMmU4Li4zMDYzOWE2IDEwMDY0NAotLS0gYS9hcmNoL21pcHMvbW0vdGxiLXI0ay5jCisrKyBiL2FyY2gvbWlwcy9tbS90bGItcjRrLmMKQEAgLTQ4OSw2ICs0ODksOCBAQAogI2lmZGVmIENPTkZJR182NEJJVAogCQlwZyB8PSBQR19FTFBBOwogI2VuZGlmCisJCWlmIChjcHVfaGFzX3JpeGlleCkKKwkJCXBnIHw9IFBHX0lFQzsKIAkJd3JpdGVfYzBfcGFnZWdyYWluKHBnKTsKIAl9CiAKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9uZXQvYnBmX2ppdC5jIGIvYXJjaC9taXBzL25ldC9icGZfaml0LmMKaW5kZXggOWZkNjgzNC4uNWQ2MTM5MyAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL25ldC9icGZfaml0LmMKKysrIGIvYXJjaC9taXBzL25ldC9icGZfaml0LmMKQEAgLTEzODgsNyArMTM4OCw3IEBACiB2b2lkIGJwZl9qaXRfZnJlZShzdHJ1Y3QgYnBmX3Byb2cgKmZwKQogewogCWlmIChmcC0+aml0ZWQpCi0JCW1vZHVsZV9mcmVlKE5VTEwsIGZwLT5icGZfZnVuYyk7CisJCW1vZHVsZV9tZW1mcmVlKGZwLT5icGZfZnVuYyk7CiAKIAlicGZfcHJvZ191bmxvY2tfZnJlZShmcCk7CiB9CmRpZmYgLS1naXQgYS9hcmNoL21uMTAzMDAvaW5jbHVkZS9hc20vY2FjaGVmbHVzaC5oIGIvYXJjaC9tbjEwMzAwL2luY2x1ZGUvYXNtL2NhY2hlZmx1c2guaAppbmRleCBmYWVkOTAyLi42ZDZkZjgzIDEwMDY0NAotLS0gYS9hcmNoL21uMTAzMDAvaW5jbHVkZS9hc20vY2FjaGVmbHVzaC5oCisrKyBiL2FyY2gvbW4xMDMwMC9pbmNsdWRlL2FzbS9jYWNoZWZsdXNoLmgKQEAgLTE1OSwxMyArMTU5LDYgQEAKICNkZWZpbmUgY29weV9mcm9tX3VzZXJfcGFnZSh2bWEsIHBhZ2UsIHZhZGRyLCBkc3QsIHNyYywgbGVuKSBcCiAJbWVtY3B5KGRzdCwgc3JjLCBsZW4pCiAKLS8qCi0gKiBJbnRlcm5hbCBkZWJ1Z2dpbmcgZnVuY3Rpb24KLSAqLwotI2lmZGVmIENPTkZJR19ERUJVR19QQUdFQUxMT0MKLWV4dGVybiB2b2lkIGtlcm5lbF9tYXBfcGFnZXMoc3RydWN0IHBhZ2UgKnBhZ2UsIGludCBudW1wYWdlcywgaW50IGVuYWJsZSk7Ci0jZW5kaWYKLQogI2VuZGlmIC8qIF9fQVNTRU1CTFlfXyAqLwogCiAjZW5kaWYgLyogX0FTTV9DQUNIRUZMVVNIX0ggKi8KZGlmZiAtLWdpdCBhL2FyY2gvbW4xMDMwMC9tbS9mYXVsdC5jIGIvYXJjaC9tbjEwMzAwL21tL2ZhdWx0LmMKaW5kZXggMzUxNmNiZC4uMGMyY2M1ZCAxMDA2NDQKLS0tIGEvYXJjaC9tbjEwMzAwL21tL2ZhdWx0LmMKKysrIGIvYXJjaC9tbjEwMzAwL21tL2ZhdWx0LmMKQEAgLTI2Miw2ICsyNjIsOCBAQAogCWlmICh1bmxpa2VseShmYXVsdCAmIFZNX0ZBVUxUX0VSUk9SKSkgewogCQlpZiAoZmF1bHQgJiBWTV9GQVVMVF9PT00pCiAJCQlnb3RvIG91dF9vZl9tZW1vcnk7CisJCWVsc2UgaWYgKGZhdWx0ICYgVk1fRkFVTFRfU0lHU0VHVikKKwkJCWdvdG8gYmFkX2FyZWE7CiAJCWVsc2UgaWYgKGZhdWx0ICYgVk1fRkFVTFRfU0lHQlVTKQogCQkJZ290byBkb19zaWdidXM7CiAJCUJVRygpOwpkaWZmIC0tZ2l0IGEvYXJjaC9tbjEwMzAwL3VuaXQtYXNiMjMwNS9wY2ktYXNiMjMwNS5jIGIvYXJjaC9tbjEwMzAwL3VuaXQtYXNiMjMwNS9wY2ktYXNiMjMwNS5jCmluZGV4IGZlYmI5Y2QuLmI1YjAzNmYgMTAwNjQ0Ci0tLSBhL2FyY2gvbW4xMDMwMC91bml0LWFzYjIzMDUvcGNpLWFzYjIzMDUuYworKysgYi9hcmNoL21uMTAzMDAvdW5pdC1hc2IyMzA1L3BjaS1hc2IyMzA1LmMKQEAgLTEwNiw3ICsxMDYsNyBAQAogCQkJCWlmICghci0+ZmxhZ3MpCiAJCQkJCWNvbnRpbnVlOwogCQkJCWlmICghci0+c3RhcnQgfHwKLQkJCQkgICAgcGNpX2NsYWltX3Jlc291cmNlKGRldiwgaWR4KSA8IDApIHsKKwkJCQkgICAgcGNpX2NsYWltX2JyaWRnZV9yZXNvdXJjZShkZXYsIGlkeCkgPCAwKSB7CiAJCQkJCXByaW50ayhLRVJOX0VSUiAiUENJOiIKIAkJCQkJICAgICAgICIgQ2Fubm90IGFsbG9jYXRlIHJlc291cmNlIgogCQkJCQkgICAgICAgIiByZWdpb24gJWQgb2YgYnJpZGdlICVzXG4iLApkaWZmIC0tZ2l0IGEvYXJjaC9tbjEwMzAwL3VuaXQtYXNiMjMwNS9wY2kuYyBiL2FyY2gvbW4xMDMwMC91bml0LWFzYjIzMDUvcGNpLmMKaW5kZXggNmI0MzM5Zi4uNDcxZmYzOSAxMDA2NDQKLS0tIGEvYXJjaC9tbjEwMzAwL3VuaXQtYXNiMjMwNS9wY2kuYworKysgYi9hcmNoL21uMTAzMDAvdW5pdC1hc2IyMzA1L3BjaS5jCkBAIC0yODEsNDIgKzI4MSwzNyBAQAogCXJldHVybiAtRU5PREVWOwogfQogCi1zdGF0aWMgaW50IGlzX3ZhbGlkX3Jlc291cmNlKHN0cnVjdCBwY2lfZGV2ICpkZXYsIGludCBpZHgpCi17Ci0JdW5zaWduZWQgaW50IGksIHR5cGVfbWFzayA9IElPUkVTT1VSQ0VfSU8gfCBJT1JFU09VUkNFX01FTTsKLQlzdHJ1Y3QgcmVzb3VyY2UgKmRldnIgPSAmZGV2LT5yZXNvdXJjZVtpZHhdLCAqYnVzcjsKLQotCWlmIChkZXYtPmJ1cykgewotCQlwY2lfYnVzX2Zvcl9lYWNoX3Jlc291cmNlKGRldi0+YnVzLCBidXNyLCBpKSB7Ci0JCQlpZiAoIWJ1c3IgfHwgKGJ1c3ItPmZsYWdzIF4gZGV2ci0+ZmxhZ3MpICYgdHlwZV9tYXNrKQotCQkJCWNvbnRpbnVlOwotCi0JCQlpZiAoZGV2ci0+c3RhcnQgJiYKLQkJCSAgICBkZXZyLT5zdGFydCA+PSBidXNyLT5zdGFydCAmJgotCQkJICAgIGRldnItPmVuZCA8PSBidXNyLT5lbmQpCi0JCQkJcmV0dXJuIDE7Ci0JCX0KLQl9Ci0KLQlyZXR1cm4gMDsKLX0KLQogc3RhdGljIHZvaWQgcGNpYmlvc19maXh1cF9kZXZpY2VfcmVzb3VyY2VzKHN0cnVjdCBwY2lfZGV2ICpkZXYpCiB7Ci0JaW50IGxpbWl0LCBpOworCWludCBpZHg7CiAKLQlpZiAoZGV2LT5idXMtPm51bWJlciAhPSAwKQorCWlmICghZGV2LT5idXMpCiAJCXJldHVybjsKIAotCWxpbWl0ID0gKGRldi0+aGRyX3R5cGUgPT0gUENJX0hFQURFUl9UWVBFX05PUk1BTCkgPwotCQlQQ0lfQlJJREdFX1JFU09VUkNFUyA6IFBDSV9OVU1fUkVTT1VSQ0VTOworCWZvciAoaWR4ID0gMDsgaWR4IDwgUENJX0JSSURHRV9SRVNPVVJDRVM7IGlkeCsrKSB7CisJCXN0cnVjdCByZXNvdXJjZSAqciA9ICZkZXYtPnJlc291cmNlW2lkeF07CiAKLQlmb3IgKGkgPSAwOyBpIDwgbGltaXQ7IGkrKykgewotCQlpZiAoIWRldi0+cmVzb3VyY2VbaV0uZmxhZ3MpCisJCWlmICghci0+ZmxhZ3MgfHwgci0+cGFyZW50IHx8ICFyLT5zdGFydCkKIAkJCWNvbnRpbnVlOwogCi0JCWlmIChpc192YWxpZF9yZXNvdXJjZShkZXYsIGkpKQotCQkJcGNpX2NsYWltX3Jlc291cmNlKGRldiwgaSk7CisJCXBjaV9jbGFpbV9yZXNvdXJjZShkZXYsIGlkeCk7CisJfQorfQorCitzdGF0aWMgdm9pZCBwY2liaW9zX2ZpeHVwX2JyaWRnZV9yZXNvdXJjZXMoc3RydWN0IHBjaV9kZXYgKmRldikKK3sKKwlpbnQgaWR4OworCisJaWYgKCFkZXYtPmJ1cykKKwkJcmV0dXJuOworCisJZm9yIChpZHggPSBQQ0lfQlJJREdFX1JFU09VUkNFUzsgaWR4IDwgUENJX05VTV9SRVNPVVJDRVM7IGlkeCsrKSB7CisJCXN0cnVjdCByZXNvdXJjZSAqciA9ICZkZXYtPnJlc291cmNlW2lkeF07CisKKwkJaWYgKCFyLT5mbGFncyB8fCByLT5wYXJlbnQgfHwgIXItPnN0YXJ0KQorCQkJY29udGludWU7CisKKwkJcGNpX2NsYWltX2JyaWRnZV9yZXNvdXJjZShkZXYsIGlkeCk7CiAJfQogfQogCkBAIC0zMzAsNyArMzI1LDcgQEAKIAogCWlmIChidXMtPnNlbGYpIHsKIAkJcGNpX3JlYWRfYnJpZGdlX2Jhc2VzKGJ1cyk7Ci0JCXBjaWJpb3NfZml4dXBfZGV2aWNlX3Jlc291cmNlcyhidXMtPnNlbGYpOworCQlwY2liaW9zX2ZpeHVwX2JyaWRnZV9yZXNvdXJjZXMoYnVzLT5zZWxmKTsKIAl9CiAKIAlsaXN0X2Zvcl9lYWNoX2VudHJ5KGRldiwgJmJ1cy0+ZGV2aWNlcywgYnVzX2xpc3QpCmRpZmYgLS1naXQgYS9hcmNoL25pb3MyL2tlcm5lbC9tb2R1bGUuYyBiL2FyY2gvbmlvczIva2VybmVsL21vZHVsZS5jCmluZGV4IGNjOTI0YTMuLmUyZTNmMTMgMTAwNjQ0Ci0tLSBhL2FyY2gvbmlvczIva2VybmVsL21vZHVsZS5jCisrKyBiL2FyY2gvbmlvczIva2VybmVsL21vZHVsZS5jCkBAIC0zNiw3ICszNiw3IEBACiB9CiAKIC8qIEZyZWUgbWVtb3J5IHJldHVybmVkIGZyb20gbW9kdWxlX2FsbG9jICovCi12b2lkIG1vZHVsZV9mcmVlKHN0cnVjdCBtb2R1bGUgKm1vZCwgdm9pZCAqbW9kdWxlX3JlZ2lvbikKK3ZvaWQgbW9kdWxlX21lbWZyZWUodm9pZCAqbW9kdWxlX3JlZ2lvbikKIHsKIAlrZnJlZShtb2R1bGVfcmVnaW9uKTsKIH0KZGlmZiAtLWdpdCBhL2FyY2gvbmlvczIva2VybmVsL3NpZ25hbC5jIGIvYXJjaC9uaW9zMi9rZXJuZWwvc2lnbmFsLmMKaW5kZXggZjlkMjc4OC4uMmQwZWEyNSAxMDA2NDQKLS0tIGEvYXJjaC9uaW9zMi9rZXJuZWwvc2lnbmFsLmMKKysrIGIvYXJjaC9uaW9zMi9rZXJuZWwvc2lnbmFsLmMKQEAgLTIwMCw3ICsyMDAsNyBAQAogCiAJLyogU2V0IHVwIHRvIHJldHVybiBmcm9tIHVzZXJzcGFjZTsganVtcCB0byBmaXhlZCBhZGRyZXNzIHNpZ3JldHVybgogCSAgIHRyYW1wb2xpbmUgb24ga3VzZXIgcGFnZS4gICovCi0JcmVncy0+cmEgPSAodW5zaWduZWQgbG9uZykgKDB4MTA0MCk7CisJcmVncy0+cmEgPSAodW5zaWduZWQgbG9uZykgKDB4MTA0NCk7CiAKIAkvKiBTZXQgdXAgcmVnaXN0ZXJzIGZvciBzaWduYWwgaGFuZGxlciAqLwogCXJlZ3MtPnNwID0gKHVuc2lnbmVkIGxvbmcpIGZyYW1lOwpkaWZmIC0tZ2l0IGEvYXJjaC9uaW9zMi9tbS9mYXVsdC5jIGIvYXJjaC9uaW9zMi9tbS9mYXVsdC5jCmluZGV4IDE1YTBiYjUuLmQxOTRjMDQgMTAwNjQ0Ci0tLSBhL2FyY2gvbmlvczIvbW0vZmF1bHQuYworKysgYi9hcmNoL25pb3MyL21tL2ZhdWx0LmMKQEAgLTEzNSw2ICsxMzUsOCBAQAogCWlmICh1bmxpa2VseShmYXVsdCAmIFZNX0ZBVUxUX0VSUk9SKSkgewogCQlpZiAoZmF1bHQgJiBWTV9GQVVMVF9PT00pCiAJCQlnb3RvIG91dF9vZl9tZW1vcnk7CisJCWVsc2UgaWYgKGZhdWx0ICYgVk1fRkFVTFRfU0lHU0VHVikKKwkJCWdvdG8gYmFkX2FyZWE7CiAJCWVsc2UgaWYgKGZhdWx0ICYgVk1fRkFVTFRfU0lHQlVTKQogCQkJZ290byBkb19zaWdidXM7CiAJCUJVRygpOwpAQCAtMTU3LDkgKzE1OSwxMSBAQAogYmFkX2FyZWFfbm9zZW1hcGhvcmU6CiAJLyogVXNlciBtb2RlIGFjY2Vzc2VzIGp1c3QgY2F1c2UgYSBTSUdTRUdWICovCiAJaWYgKHVzZXJfbW9kZShyZWdzKSkgewotCQlwcl9hbGVydCgiJXM6IHVuaGFuZGxlZCBwYWdlIGZhdWx0ICglZCkgYXQgMHglMDhseCwgIgotCQkJImNhdXNlICVsZFxuIiwgY3VycmVudC0+Y29tbSwgU0lHU0VHViwgYWRkcmVzcywgY2F1c2UpOwotCQlzaG93X3JlZ3MocmVncyk7CisJCWlmICh1bmhhbmRsZWRfc2lnbmFsKGN1cnJlbnQsIFNJR1NFR1YpICYmIHByaW50a19yYXRlbGltaXQoKSkgeworCQkJcHJfaW5mbygiJXM6IHVuaGFuZGxlZCBwYWdlIGZhdWx0ICglZCkgYXQgMHglMDhseCwgIgorCQkJCSJjYXVzZSAlbGRcbiIsIGN1cnJlbnQtPmNvbW0sIFNJR1NFR1YsIGFkZHJlc3MsIGNhdXNlKTsKKwkJCXNob3dfcmVncyhyZWdzKTsKKwkJfQogCQlfZXhjZXB0aW9uKFNJR1NFR1YsIHJlZ3MsIGNvZGUsIGFkZHJlc3MpOwogCQlyZXR1cm47CiAJfQpkaWZmIC0tZ2l0IGEvYXJjaC9vcGVucmlzYy9tbS9mYXVsdC5jIGIvYXJjaC9vcGVucmlzYy9tbS9mYXVsdC5jCmluZGV4IDA3MDNhY2YuLjIzMGFjMjAgMTAwNjQ0Ci0tLSBhL2FyY2gvb3BlbnJpc2MvbW0vZmF1bHQuYworKysgYi9hcmNoL29wZW5yaXNjL21tL2ZhdWx0LmMKQEAgLTE3MSw2ICsxNzEsOCBAQAogCWlmICh1bmxpa2VseShmYXVsdCAmIFZNX0ZBVUxUX0VSUk9SKSkgewogCQlpZiAoZmF1bHQgJiBWTV9GQVVMVF9PT00pCiAJCQlnb3RvIG91dF9vZl9tZW1vcnk7CisJCWVsc2UgaWYgKGZhdWx0ICYgVk1fRkFVTFRfU0lHU0VHVikKKwkJCWdvdG8gYmFkX2FyZWE7CiAJCWVsc2UgaWYgKGZhdWx0ICYgVk1fRkFVTFRfU0lHQlVTKQogCQkJZ290byBkb19zaWdidXM7CiAJCUJVRygpOwpkaWZmIC0tZ2l0IGEvYXJjaC9wYXJpc2Mva2VybmVsL21vZHVsZS5jIGIvYXJjaC9wYXJpc2Mva2VybmVsL21vZHVsZS5jCmluZGV4IDUwZGZhZmMuLjU4MjJlOGUgMTAwNjQ0Ci0tLSBhL2FyY2gvcGFyaXNjL2tlcm5lbC9tb2R1bGUuYworKysgYi9hcmNoL3BhcmlzYy9rZXJuZWwvbW9kdWxlLmMKQEAgLTI5OCwxNCArMjk4LDEwIEBACiB9CiAjZW5kaWYKIAotCi0vKiBGcmVlIG1lbW9yeSByZXR1cm5lZCBmcm9tIG1vZHVsZV9hbGxvYyAqLwotdm9pZCBtb2R1bGVfZnJlZShzdHJ1Y3QgbW9kdWxlICptb2QsIHZvaWQgKm1vZHVsZV9yZWdpb24pCit2b2lkIG1vZHVsZV9hcmNoX2ZyZWVpbmdfaW5pdChzdHJ1Y3QgbW9kdWxlICptb2QpCiB7CiAJa2ZyZWUobW9kLT5hcmNoLnNlY3Rpb24pOwogCW1vZC0+YXJjaC5zZWN0aW9uID0gTlVMTDsKLQotCXZmcmVlKG1vZHVsZV9yZWdpb24pOwogfQogCiAvKiBBZGRpdGlvbmFsIGJ5dGVzIG5lZWRlZCBpbiBmcm9udCBvZiBpbmRpdmlkdWFsIHNlY3Rpb25zICovCmRpZmYgLS1naXQgYS9hcmNoL3BhcmlzYy9tbS9mYXVsdC5jIGIvYXJjaC9wYXJpc2MvbW0vZmF1bHQuYwppbmRleCAzY2E5YzExLi5lNTEyMGU2IDEwMDY0NAotLS0gYS9hcmNoL3BhcmlzYy9tbS9mYXVsdC5jCisrKyBiL2FyY2gvcGFyaXNjL21tL2ZhdWx0LmMKQEAgLTI1Niw2ICsyNTYsOCBAQAogCQkgKi8KIAkJaWYgKGZhdWx0ICYgVk1fRkFVTFRfT09NKQogCQkJZ290byBvdXRfb2ZfbWVtb3J5OworCQllbHNlIGlmIChmYXVsdCAmIFZNX0ZBVUxUX1NJR1NFR1YpCisJCQlnb3RvIGJhZF9hcmVhOwogCQllbHNlIGlmIChmYXVsdCAmIFZNX0ZBVUxUX1NJR0JVUykKIAkJCWdvdG8gYmFkX2FyZWE7CiAJCUJVRygpOwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NyeXB0by9zaGExLmMgYi9hcmNoL3Bvd2VycGMvY3J5cHRvL3NoYTEuYwppbmRleCBkM2ZlYmE1YTIuLmMxNTRjZWIgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9jcnlwdG8vc2hhMS5jCisrKyBiL2FyY2gvcG93ZXJwYy9jcnlwdG8vc2hhMS5jCkBAIC0xNTQsNCArMTU0LDUgQEAKIE1PRFVMRV9MSUNFTlNFKCJHUEwiKTsKIE1PRFVMRV9ERVNDUklQVElPTigiU0hBMSBTZWN1cmUgSGFzaCBBbGdvcml0aG0iKTsKIAorTU9EVUxFX0FMSUFTX0NSWVBUTygic2hhMSIpOwogTU9EVUxFX0FMSUFTX0NSWVBUTygic2hhMS1wb3dlcnBjIik7CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vY2FjaGVmbHVzaC5oIGIvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL2NhY2hlZmx1c2guaAppbmRleCA1YjkzMTIyLi4zMGIzNWZmIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vY2FjaGVmbHVzaC5oCisrKyBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9jYWNoZWZsdXNoLmgKQEAgLTYwLDEzICs2MCw2IEBACiAjZGVmaW5lIGNvcHlfZnJvbV91c2VyX3BhZ2Uodm1hLCBwYWdlLCB2YWRkciwgZHN0LCBzcmMsIGxlbikgXAogCW1lbWNweShkc3QsIHNyYywgbGVuKQogCi0KLQotI2lmZGVmIENPTkZJR19ERUJVR19QQUdFQUxMT0MKLS8qIGludGVybmFsIGRlYnVnZ2luZyBmdW5jdGlvbiAqLwotdm9pZCBrZXJuZWxfbWFwX3BhZ2VzKHN0cnVjdCBwYWdlICpwYWdlLCBpbnQgbnVtcGFnZXMsIGludCBlbmFibGUpOwotI2VuZGlmCi0KICNlbmRpZiAvKiBfX0tFUk5FTF9fICovCiAKICNlbmRpZiAvKiBfQVNNX1BPV0VSUENfQ0FDSEVGTFVTSF9IICovCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMva2VybmVsL3BjaS1jb21tb24uYyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvcGNpLWNvbW1vbi5jCmluZGV4IDM3ZDUxMmQuLjJhNTI1YzkgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvcGNpLWNvbW1vbi5jCisrKyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvcGNpLWNvbW1vbi5jCkBAIC0xMTg0LDYgKzExODQsOCBAQAogCQkJIHByLCAocHIgJiYgcHItPm5hbWUpID8gcHItPm5hbWUgOiAibmlsIik7CiAKIAkJaWYgKHByICYmICEocHItPmZsYWdzICYgSU9SRVNPVVJDRV9VTlNFVCkpIHsKKwkJCXN0cnVjdCBwY2lfZGV2ICpkZXYgPSBidXMtPnNlbGY7CisKIAkJCWlmIChyZXF1ZXN0X3Jlc291cmNlKHByLCByZXMpID09IDApCiAJCQkJY29udGludWU7CiAJCQkvKgpAQCAtMTE5Myw2ICsxMTk1LDExIEBACiAJCQkgKi8KIAkJCWlmIChyZXBhcmVudF9yZXNvdXJjZXMocHIsIHJlcykgPT0gMCkKIAkJCQljb250aW51ZTsKKworCQkJaWYgKGRldiAmJiBpIDwgUENJX0JSSURHRV9SRVNPVVJDRV9OVU0gJiYKKwkJCSAgICBwY2lfY2xhaW1fYnJpZGdlX3Jlc291cmNlKGRldiwKKwkJCQkJCWkgKyBQQ0lfQlJJREdFX1JFU09VUkNFUykgPT0gMCkKKwkJCQljb250aW51ZTsKIAkJfQogCQlwcl93YXJuaW5nKCJQQ0k6IENhbm5vdCBhbGxvY2F0ZSByZXNvdXJjZSByZWdpb24gIgogCQkJICAgIiVkIG9mIFBDSSBicmlkZ2UgJWQsIHdpbGwgcmVtYXBcbiIsIGksIGJ1cy0+bnVtYmVyKTsKQEAgLTE0MDEsNyArMTQwOCwxMCBAQAogCQkJCSAodW5zaWduZWQgbG9uZyBsb25nKXItPmVuZCwKIAkJCQkgKHVuc2lnbmVkIGludClyLT5mbGFncyk7CiAKLQkJCXBjaV9jbGFpbV9yZXNvdXJjZShkZXYsIGkpOworCQkJaWYgKHBjaV9jbGFpbV9yZXNvdXJjZShkZXYsIGkpID09IDApCisJCQkJY29udGludWU7CisKKwkJCXBjaV9jbGFpbV9icmlkZ2VfcmVzb3VyY2UoZGV2LCBpKTsKIAkJfQogCX0KIApkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL21tL2NvcHJvX2ZhdWx0LmMgYi9hcmNoL3Bvd2VycGMvbW0vY29wcm9fZmF1bHQuYwppbmRleCA1YTIzNmYwLi4xYjUzMDVkIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvbW0vY29wcm9fZmF1bHQuYworKysgYi9hcmNoL3Bvd2VycGMvbW0vY29wcm9fZmF1bHQuYwpAQCAtNzYsNyArNzYsNyBAQAogCQlpZiAoKmZsdCAmIFZNX0ZBVUxUX09PTSkgewogCQkJcmV0ID0gLUVOT01FTTsKIAkJCWdvdG8gb3V0X3VubG9jazsKLQkJfSBlbHNlIGlmICgqZmx0ICYgVk1fRkFVTFRfU0lHQlVTKSB7CisJCX0gZWxzZSBpZiAoKmZsdCAmIChWTV9GQVVMVF9TSUdCVVMgfCBWTV9GQVVMVF9TSUdTRUdWKSkgewogCQkJcmV0ID0gLUVGQVVMVDsKIAkJCWdvdG8gb3V0X3VubG9jazsKIAkJfQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL21tL2ZhdWx0LmMgYi9hcmNoL3Bvd2VycGMvbW0vZmF1bHQuYwppbmRleCBlYjc5OTA3Li42MTU0YjBhIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvbW0vZmF1bHQuYworKysgYi9hcmNoL3Bvd2VycGMvbW0vZmF1bHQuYwpAQCAtNDM3LDYgKzQzNyw4IEBACiAJICovCiAJZmF1bHQgPSBoYW5kbGVfbW1fZmF1bHQobW0sIHZtYSwgYWRkcmVzcywgZmxhZ3MpOwogCWlmICh1bmxpa2VseShmYXVsdCAmIChWTV9GQVVMVF9SRVRSWXxWTV9GQVVMVF9FUlJPUikpKSB7CisJCWlmIChmYXVsdCAmIFZNX0ZBVUxUX1NJR1NFR1YpCisJCQlnb3RvIGJhZF9hcmVhOwogCQlyYyA9IG1tX2ZhdWx0X2Vycm9yKHJlZ3MsIGFkZHJlc3MsIGZhdWx0KTsKIAkJaWYgKHJjID49IE1NX0ZBVUxUX1JFVFVSTikKIAkJCWdvdG8gYmFpbDsKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9uZXQvYnBmX2ppdF9jb21wLmMgYi9hcmNoL3Bvd2VycGMvbmV0L2JwZl9qaXRfY29tcC5jCmluZGV4IDFjYTEyNWIuLmQxOTE2YjUgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9uZXQvYnBmX2ppdF9jb21wLmMKKysrIGIvYXJjaC9wb3dlcnBjL25ldC9icGZfaml0X2NvbXAuYwpAQCAtNjk5LDcgKzY5OSw3IEBACiB2b2lkIGJwZl9qaXRfZnJlZShzdHJ1Y3QgYnBmX3Byb2cgKmZwKQogewogCWlmIChmcC0+aml0ZWQpCi0JCW1vZHVsZV9mcmVlKE5VTEwsIGZwLT5icGZfZnVuYyk7CisJCW1vZHVsZV9tZW1mcmVlKGZwLT5icGZfZnVuYyk7CiAKIAlicGZfcHJvZ191bmxvY2tfZnJlZShmcCk7CiB9CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL3Bvd2VybnYvc2V0dXAuYyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcG93ZXJudi9zZXR1cC5jCmluZGV4IGI3MDBhMzIuLmQyZGU3ZDUgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcG93ZXJudi9zZXR1cC5jCisrKyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcG93ZXJudi9zZXR1cC5jCkBAIC0zMDQsNyArMzA0LDcgQEAKIAkgKiBhbGwgY3B1cyBhdCBib290LiBHZXQgdGhlc2UgcmVnIHZhbHVlcyBvZiBjdXJyZW50IGNwdSBhbmQgdXNlIHRoZQogCSAqIHNhbWUgYWNjcm9zcyBhbGwgY3B1cy4KIAkgKi8KLQl1aW50NjRfdCBscGNyX3ZhbCA9IG1mc3ByKFNQUk5fTFBDUik7CisJdWludDY0X3QgbHBjcl92YWwgPSBtZnNwcihTUFJOX0xQQ1IpICYgfih1NjQpTFBDUl9QRUNFMTsKIAl1aW50NjRfdCBoaWQwX3ZhbCA9IG1mc3ByKFNQUk5fSElEMCk7CiAJdWludDY0X3QgaGlkMV92YWwgPSBtZnNwcihTUFJOX0hJRDEpOwogCXVpbnQ2NF90IGhpZDRfdmFsID0gbWZzcHIoU1BSTl9ISUQ0KTsKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy94bW9uL3htb24uYyBiL2FyY2gvcG93ZXJwYy94bW9uL3htb24uYwppbmRleCA1YjE1MGYwLi4xM2M2ZTIwIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMveG1vbi94bW9uLmMKKysrIGIvYXJjaC9wb3dlcnBjL3htb24veG1vbi5jCkBAIC0zMzcsNiArMzM3LDcgQEAKIAlhcmdzLnRva2VuID0gcnRhc190b2tlbigic2V0LWluZGljYXRvciIpOwogCWlmIChhcmdzLnRva2VuID09IFJUQVNfVU5LTk9XTl9TRVJWSUNFKQogCQlyZXR1cm47CisJYXJncy50b2tlbiA9IGNwdV90b19iZTMyKGFyZ3MudG9rZW4pOwogCWFyZ3MubmFyZ3MgPSBjcHVfdG9fYmUzMigzKTsKIAlhcmdzLm5yZXQgPSBjcHVfdG9fYmUzMigxKTsKIAlhcmdzLnJldHMgPSAmYXJncy5hcmdzWzNdOwpkaWZmIC0tZ2l0IGEvYXJjaC9zMzkwL2luY2x1ZGUvYXNtL2NhY2hlZmx1c2guaCBiL2FyY2gvczM5MC9pbmNsdWRlL2FzbS9jYWNoZWZsdXNoLmgKaW5kZXggM2UyMDM4My4uNThmYWU3ZCAxMDA2NDQKLS0tIGEvYXJjaC9zMzkwL2luY2x1ZGUvYXNtL2NhY2hlZmx1c2guaAorKysgYi9hcmNoL3MzOTAvaW5jbHVkZS9hc20vY2FjaGVmbHVzaC5oCkBAIC00LDEwICs0LDYgQEAKIC8qIENhY2hlcyBhcmVuJ3QgYnJhaW4tZGVhZCBvbiB0aGUgczM5MC4gKi8KICNpbmNsdWRlIDxhc20tZ2VuZXJpYy9jYWNoZWZsdXNoLmg+CiAKLSNpZmRlZiBDT05GSUdfREVCVUdfUEFHRUFMTE9DCi12b2lkIGtlcm5lbF9tYXBfcGFnZXMoc3RydWN0IHBhZ2UgKnBhZ2UsIGludCBudW1wYWdlcywgaW50IGVuYWJsZSk7Ci0jZW5kaWYKLQogaW50IHNldF9tZW1vcnlfcm8odW5zaWduZWQgbG9uZyBhZGRyLCBpbnQgbnVtcGFnZXMpOwogaW50IHNldF9tZW1vcnlfcncodW5zaWduZWQgbG9uZyBhZGRyLCBpbnQgbnVtcGFnZXMpOwogaW50IHNldF9tZW1vcnlfbngodW5zaWduZWQgbG9uZyBhZGRyLCBpbnQgbnVtcGFnZXMpOwpkaWZmIC0tZ2l0IGEvYXJjaC9zMzkwL2tlcm5lbC9tb2R1bGUuYyBiL2FyY2gvczM5MC9rZXJuZWwvbW9kdWxlLmMKaW5kZXggYjg5YjU5MS4uNDA5ZDE1MiAxMDA2NDQKLS0tIGEvYXJjaC9zMzkwL2tlcm5lbC9tb2R1bGUuYworKysgYi9hcmNoL3MzOTAva2VybmVsL21vZHVsZS5jCkBAIC01NSwxNCArNTUsMTAgQEAKIH0KICNlbmRpZgogCi0vKiBGcmVlIG1lbW9yeSByZXR1cm5lZCBmcm9tIG1vZHVsZV9hbGxvYyAqLwotdm9pZCBtb2R1bGVfZnJlZShzdHJ1Y3QgbW9kdWxlICptb2QsIHZvaWQgKm1vZHVsZV9yZWdpb24pCit2b2lkIG1vZHVsZV9hcmNoX2ZyZWVpbmdfaW5pdChzdHJ1Y3QgbW9kdWxlICptb2QpCiB7Ci0JaWYgKG1vZCkgewotCQl2ZnJlZShtb2QtPmFyY2guc3ltaW5mbyk7Ci0JCW1vZC0+YXJjaC5zeW1pbmZvID0gTlVMTDsKLQl9Ci0JdmZyZWUobW9kdWxlX3JlZ2lvbik7CisJdmZyZWUobW9kLT5hcmNoLnN5bWluZm8pOworCW1vZC0+YXJjaC5zeW1pbmZvID0gTlVMTDsKIH0KIAogc3RhdGljIHZvaWQgY2hlY2tfcmVsYShFbGZfUmVsYSAqcmVsYSwgc3RydWN0IG1vZHVsZSAqbWUpCmRpZmYgLS1naXQgYS9hcmNoL3MzOTAvbW0vZmF1bHQuYyBiL2FyY2gvczM5MC9tbS9mYXVsdC5jCmluZGV4IDgxMTkzN2IuLjkwNjVkNWEgMTAwNjQ0Ci0tLSBhL2FyY2gvczM5MC9tbS9mYXVsdC5jCisrKyBiL2FyY2gvczM5MC9tbS9mYXVsdC5jCkBAIC0zNzQsNiArMzc0LDEyIEBACiAJCQkJZG9fbm9fY29udGV4dChyZWdzKTsKIAkJCWVsc2UKIAkJCQlwYWdlZmF1bHRfb3V0X29mX21lbW9yeSgpOworCQl9IGVsc2UgaWYgKGZhdWx0ICYgVk1fRkFVTFRfU0lHU0VHVikgeworCQkJLyogS2VybmVsIG1vZGU/IEhhbmRsZSBleGNlcHRpb25zIG9yIGRpZSAqLworCQkJaWYgKCF1c2VyX21vZGUocmVncykpCisJCQkJZG9fbm9fY29udGV4dChyZWdzKTsKKwkJCWVsc2UKKwkJCQlkb19zaWdzZWd2KHJlZ3MsIFNFR1ZfTUFQRVJSKTsKIAkJfSBlbHNlIGlmIChmYXVsdCAmIFZNX0ZBVUxUX1NJR0JVUykgewogCQkJLyogS2VybmVsIG1vZGU/IEhhbmRsZSBleGNlcHRpb25zIG9yIGRpZSAqLwogCQkJaWYgKCF1c2VyX21vZGUocmVncykpCmRpZmYgLS1naXQgYS9hcmNoL3MzOTAvbmV0L2JwZl9qaXQuUyBiL2FyY2gvczM5MC9uZXQvYnBmX2ppdC5TCmluZGV4IDdlNDVkMTMuLmJhNDRjOWYgMTAwNjQ0Ci0tLSBhL2FyY2gvczM5MC9uZXQvYnBmX2ppdC5TCisrKyBiL2FyY2gvczM5MC9uZXQvYnBmX2ppdC5TCkBAIC0yMiw4ICsyMiw4IEBACiAgKiBza2JfY29weV9iaXRzIHRha2VzIDQgcGFyYW1ldGVyczoKICAqICAgJXIyID0gc2tiIHBvaW50ZXIKICAqICAgJXIzID0gb2Zmc2V0IGludG8gc2tiIGRhdGEKLSAqICAgJXI0ID0gbGVuZ3RoIHRvIGNvcHkKLSAqICAgJXI1ID0gcG9pbnRlciB0byB0ZW1wIGJ1ZmZlcgorICogICAlcjQgPSBwb2ludGVyIHRvIHRlbXAgYnVmZmVyCisgKiAgICVyNSA9IGxlbmd0aCB0byBjb3B5CiAgKi8KICNkZWZpbmUgU0tCREFUQQklcjgKIApAQCAtNDQsOCArNDQsOSBAQAogCiBza19sb2FkX3dvcmRfc2xvdzoKIAlsZ3IJJXI5LCVyMgkJCSMgc2F2ZSAlcjIKLQlsaGkJJXI0LDQJCQkjIDQgYnl0ZXMKLQlsYQklcjUsMTYwKCVyMTUpCQkjIHBvaW50ZXIgdG8gdGVtcCBidWZmZXIKKwlsZ3IJJXIzLCVyMQkJCSMgb2Zmc2V0CisJbGEJJXI0LDE2MCglcjE1KQkJIyBwb2ludGVyIHRvIHRlbXAgYnVmZmVyCisJbGdoaQklcjUsNAkJCSMgNCBieXRlcwogCWJyYXNsCSVyMTQsc2tiX2NvcHlfYml0cwkjIGdldCBkYXRhIGZyb20gc2tiCiAJbAklcjUsMTYwKCVyMTUpCQkjIGxvYWQgcmVzdWx0IGZyb20gdGVtcCBidWZmZXIKIAlsdGdyCSVyMiwlcjIJCQkjIHNldCBjYyB0byAoJXIyICE9IDApCkBAIC02OSw4ICs3MCw5IEBACiAKIHNrX2xvYWRfaGFsZl9zbG93OgogCWxncgklcjksJXIyCQkJIyBzYXZlICVyMgotCWxoaQklcjQsMgkJCSMgMiBieXRlcwotCWxhCSVyNSwxNjIoJXIxNSkJCSMgcG9pbnRlciB0byB0ZW1wIGJ1ZmZlcgorCWxncgklcjMsJXIxCQkJIyBvZmZzZXQKKwlsYQklcjQsMTYyKCVyMTUpCQkjIHBvaW50ZXIgdG8gdGVtcCBidWZmZXIKKwlsZ2hpCSVyNSwyCQkJIyAyIGJ5dGVzCiAJYnJhc2wJJXIxNCxza2JfY29weV9iaXRzCSMgZ2V0IGRhdGEgZnJvbSBza2IKIAl4YwkxNjAoMiwlcjE1KSwxNjAoJXIxNSkKIAlsCSVyNSwxNjAoJXIxNSkJCSMgbG9hZCByZXN1bHQgZnJvbSB0ZW1wIGJ1ZmZlcgpAQCAtOTUsOCArOTcsOSBAQAogCiBza19sb2FkX2J5dGVfc2xvdzoKIAlsZ3IJJXI5LCVyMgkJCSMgc2F2ZSAlcjIKLQlsaGkJJXI0LDEJCQkjIDEgYnl0ZXMKLQlsYQklcjUsMTYzKCVyMTUpCQkjIHBvaW50ZXIgdG8gdGVtcCBidWZmZXIKKwlsZ3IJJXIzLCVyMQkJCSMgb2Zmc2V0CisJbGEJJXI0LDE2MyglcjE1KQkJIyBwb2ludGVyIHRvIHRlbXAgYnVmZmVyCisJbGdoaQklcjUsMQkJCSMgMSBieXRlCiAJYnJhc2wJJXIxNCxza2JfY29weV9iaXRzCSMgZ2V0IGRhdGEgZnJvbSBza2IKIAl4YwkxNjAoMywlcjE1KSwxNjAoJXIxNSkKIAlsCSVyNSwxNjAoJXIxNSkJCSMgbG9hZCByZXN1bHQgZnJvbSB0ZW1wIGJ1ZmZlcgpAQCAtMTA0LDExICsxMDcsMTEgQEAKIAlsZ3IJJXIyLCVyOQkJCSMgcmVzdG9yZSAlcjIKIAlicgklcjgKIAotCS8qIEEgPSAoKih1OCAqKShza2ItPmRhdGErSykgJiAweGYpIDw8IDIgKi8KKwkvKiBYID0gKCoodTggKikoc2tiLT5kYXRhK0spICYgMHhmKSA8PCAyICovCiBFTlRSWShza19sb2FkX2J5dGVfbXNoKQogCWxsZ2ZyCSVyMSwlcjMJCQkjIGV4dGVuZCBvZmZzZXQKIAljbHIJJXIxMSwlcjMJCSMgaGxlbiA8IG9mZnNldCA/Ci0JamxlCXNrX2xvYWRfYnl0ZV9zbG93CisJamxlCXNrX2xvYWRfYnl0ZV9tc2hfc2xvdwogCWxoaQklcjEyLDAKIAlpYwklcjEyLDAoJXIxLCVyMTApCSMgZ2V0IGJ5dGUgZnJvbSBza2IKIAluaWxsCSVyMTIsMHgwZgpAQCAtMTE4LDggKzEyMSw5IEBACiAKIHNrX2xvYWRfYnl0ZV9tc2hfc2xvdzoKIAlsZ3IJJXI5LCVyMgkJCSMgc2F2ZSAlcjIKLQlsaGkJJXI0LDIJCQkjIDIgYnl0ZXMKLQlsYQklcjUsMTYyKCVyMTUpCQkjIHBvaW50ZXIgdG8gdGVtcCBidWZmZXIKKwlsZ3IJJXIzLCVyMQkJCSMgb2Zmc2V0CisJbGEJJXI0LDE2MyglcjE1KQkJIyBwb2ludGVyIHRvIHRlbXAgYnVmZmVyCisJbGdoaQklcjUsMQkJCSMgMSBieXRlCiAJYnJhc2wJJXIxNCxza2JfY29weV9iaXRzCSMgZ2V0IGRhdGEgZnJvbSBza2IKIAl4YwkxNjAoMywlcjE1KSwxNjAoJXIxNSkKIAlsCSVyMTIsMTYwKCVyMTUpCQkjIGxvYWQgcmVzdWx0IGZyb20gdGVtcCBidWZmZXIKZGlmZiAtLWdpdCBhL2FyY2gvczM5MC9uZXQvYnBmX2ppdF9jb21wLmMgYi9hcmNoL3MzOTAvbmV0L2JwZl9qaXRfY29tcC5jCmluZGV4IDUyNDQ5NmQuLmJiZDE5ODEgMTAwNjQ0Ci0tLSBhL2FyY2gvczM5MC9uZXQvYnBmX2ppdF9jb21wLmMKKysrIGIvYXJjaC9zMzkwL25ldC9icGZfaml0X2NvbXAuYwpAQCAtNDQ4LDE1ICs0NDgsMTIgQEAKIAkJbWFzayA9IDB4ODAwMDAwOyAvKiBqZSAqLwoga2JyYW5jaDoJLyogRW1pdCBjb21wYXJlIGlmIHRoZSBicmFuY2ggdGFyZ2V0cyBhcmUgZGlmZmVyZW50ICovCiAJCWlmIChmaWx0ZXItPmp0ICE9IGZpbHRlci0+amYpIHsKLQkJCWlmIChLIDw9IDE2MzgzKQotCQkJCS8qIGNoaSAlcjUsPEs+ICovCi0JCQkJRU1JVDRfSU1NKDB4YTc1ZTAwMDAsIEspOwotCQkJZWxzZSBpZiAodGVzdF9mYWNpbGl0eSgyMSkpCisJCQlpZiAodGVzdF9mYWNpbGl0eSgyMSkpCiAJCQkJLyogY2xmaSAlcjUsPEs+ICovCiAJCQkJRU1JVDZfSU1NKDB4YzI1ZjAwMDAsIEspOwogCQkJZWxzZQotCQkJCS8qIGMgJXI1LDxkKEspPiglcjEzKSAqLwotCQkJCUVNSVQ0X0RJU1AoMHg1OTUwZDAwMCwgRU1JVF9DT05TVChLKSk7CisJCQkJLyogY2wgJXI1LDxkKEspPiglcjEzKSAqLworCQkJCUVNSVQ0X0RJU1AoMHg1NTUwZDAwMCwgRU1JVF9DT05TVChLKSk7CiAJCX0KIGJyYW5jaDoJCWlmIChmaWx0ZXItPmp0ID09IGZpbHRlci0+amYpIHsKIAkJCWlmIChmaWx0ZXItPmp0ID09IDApCmRpZmYgLS1naXQgYS9hcmNoL3Njb3JlL21tL2ZhdWx0LmMgYi9hcmNoL3Njb3JlL21tL2ZhdWx0LmMKaW5kZXggNTIyMzg5ODMuLjY4NjBiZWIgMTAwNjQ0Ci0tLSBhL2FyY2gvc2NvcmUvbW0vZmF1bHQuYworKysgYi9hcmNoL3Njb3JlL21tL2ZhdWx0LmMKQEAgLTExNCw2ICsxMTQsOCBAQAogCWlmICh1bmxpa2VseShmYXVsdCAmIFZNX0ZBVUxUX0VSUk9SKSkgewogCQlpZiAoZmF1bHQgJiBWTV9GQVVMVF9PT00pCiAJCQlnb3RvIG91dF9vZl9tZW1vcnk7CisJCWVsc2UgaWYgKGZhdWx0ICYgVk1fRkFVTFRfU0lHU0VHVikKKwkJCWdvdG8gYmFkX2FyZWE7CiAJCWVsc2UgaWYgKGZhdWx0ICYgVk1fRkFVTFRfU0lHQlVTKQogCQkJZ290byBkb19zaWdidXM7CiAJCUJVRygpOwpkaWZmIC0tZ2l0IGEvYXJjaC9zaC9tbS9mYXVsdC5jIGIvYXJjaC9zaC9tbS9mYXVsdC5jCmluZGV4IDU0MWRjNjEuLmE1OGZlYzkgMTAwNjQ0Ci0tLSBhL2FyY2gvc2gvbW0vZmF1bHQuYworKysgYi9hcmNoL3NoL21tL2ZhdWx0LmMKQEAgLTM1Myw2ICszNTMsOCBAQAogCX0gZWxzZSB7CiAJCWlmIChmYXVsdCAmIFZNX0ZBVUxUX1NJR0JVUykKIAkJCWRvX3NpZ2J1cyhyZWdzLCBlcnJvcl9jb2RlLCBhZGRyZXNzKTsKKwkJZWxzZSBpZiAoZmF1bHQgJiBWTV9GQVVMVF9TSUdTRUdWKQorCQkJYmFkX2FyZWEocmVncywgZXJyb3JfY29kZSwgYWRkcmVzcyk7CiAJCWVsc2UKIAkJCUJVRygpOwogCX0KZGlmZiAtLWdpdCBhL2FyY2gvc3BhcmMvaW5jbHVkZS9hc20vY2FjaGVmbHVzaF82NC5oIGIvYXJjaC9zcGFyYy9pbmNsdWRlL2FzbS9jYWNoZWZsdXNoXzY0LmgKaW5kZXggMzg5NjUzNy4uNjg1MTNjNCAxMDA2NDQKLS0tIGEvYXJjaC9zcGFyYy9pbmNsdWRlL2FzbS9jYWNoZWZsdXNoXzY0LmgKKysrIGIvYXJjaC9zcGFyYy9pbmNsdWRlL2FzbS9jYWNoZWZsdXNoXzY0LmgKQEAgLTc0LDExICs3NCw2IEBACiAjZGVmaW5lIGZsdXNoX2NhY2hlX3ZtYXAoc3RhcnQsIGVuZCkJCWRvIHsgfSB3aGlsZSAoMCkKICNkZWZpbmUgZmx1c2hfY2FjaGVfdnVubWFwKHN0YXJ0LCBlbmQpCQlkbyB7IH0gd2hpbGUgKDApCiAKLSNpZmRlZiBDT05GSUdfREVCVUdfUEFHRUFMTE9DCi0vKiBpbnRlcm5hbCBkZWJ1Z2dpbmcgZnVuY3Rpb24gKi8KLXZvaWQga2VybmVsX21hcF9wYWdlcyhzdHJ1Y3QgcGFnZSAqcGFnZSwgaW50IG51bXBhZ2VzLCBpbnQgZW5hYmxlKTsKLSNlbmRpZgotCiAjZW5kaWYgLyogIV9fQVNTRU1CTFlfXyAqLwogCiAjZW5kaWYgLyogX1NQQVJDNjRfQ0FDSEVGTFVTSF9IICovCmRpZmYgLS1naXQgYS9hcmNoL3NwYXJjL2tlcm5lbC9wY2kuYyBiL2FyY2gvc3BhcmMva2VybmVsL3BjaS5jCmluZGV4IGIzNjM2NWYuLjljZTVhZmUgMTAwNjQ0Ci0tLSBhL2FyY2gvc3BhcmMva2VybmVsL3BjaS5jCisrKyBiL2FyY2gvc3BhcmMva2VybmVsL3BjaS5jCkBAIC02MzksNyArNjM5LDEwIEBACiAJCQkJICAgICAgICh1bnNpZ25lZCBsb25nIGxvbmcpci0+ZW5kLAogCQkJCSAgICAgICAodW5zaWduZWQgaW50KXItPmZsYWdzKTsKIAotCQkJcGNpX2NsYWltX3Jlc291cmNlKGRldiwgaSk7CisJCQlpZiAocGNpX2NsYWltX3Jlc291cmNlKGRldiwgaSkgPT0gMCkKKwkJCQljb250aW51ZTsKKworCQkJcGNpX2NsYWltX2JyaWRnZV9yZXNvdXJjZShkZXYsIGkpOwogCQl9CiAJfQogCmRpZmYgLS1naXQgYS9hcmNoL3NwYXJjL21tL2ZhdWx0XzMyLmMgYi9hcmNoL3NwYXJjL21tL2ZhdWx0XzMyLmMKaW5kZXggOTA4ZThjMS4uNzBkODE3MSAxMDA2NDQKLS0tIGEvYXJjaC9zcGFyYy9tbS9mYXVsdF8zMi5jCisrKyBiL2FyY2gvc3BhcmMvbW0vZmF1bHRfMzIuYwpAQCAtMjQ5LDYgKzI0OSw4IEBACiAJaWYgKHVubGlrZWx5KGZhdWx0ICYgVk1fRkFVTFRfRVJST1IpKSB7CiAJCWlmIChmYXVsdCAmIFZNX0ZBVUxUX09PTSkKIAkJCWdvdG8gb3V0X29mX21lbW9yeTsKKwkJZWxzZSBpZiAoZmF1bHQgJiBWTV9GQVVMVF9TSUdTRUdWKQorCQkJZ290byBiYWRfYXJlYTsKIAkJZWxzZSBpZiAoZmF1bHQgJiBWTV9GQVVMVF9TSUdCVVMpCiAJCQlnb3RvIGRvX3NpZ2J1czsKIAkJQlVHKCk7CmRpZmYgLS1naXQgYS9hcmNoL3NwYXJjL21tL2ZhdWx0XzY0LmMgYi9hcmNoL3NwYXJjL21tL2ZhdWx0XzY0LmMKaW5kZXggMThmY2Q3MS4uNDc5ODIzMiAxMDA2NDQKLS0tIGEvYXJjaC9zcGFyYy9tbS9mYXVsdF82NC5jCisrKyBiL2FyY2gvc3BhcmMvbW0vZmF1bHRfNjQuYwpAQCAtNDQ2LDYgKzQ0Niw4IEBACiAJaWYgKHVubGlrZWx5KGZhdWx0ICYgVk1fRkFVTFRfRVJST1IpKSB7CiAJCWlmIChmYXVsdCAmIFZNX0ZBVUxUX09PTSkKIAkJCWdvdG8gb3V0X29mX21lbW9yeTsKKwkJZWxzZSBpZiAoZmF1bHQgJiBWTV9GQVVMVF9TSUdTRUdWKQorCQkJZ290byBiYWRfYXJlYTsKIAkJZWxzZSBpZiAoZmF1bHQgJiBWTV9GQVVMVF9TSUdCVVMpCiAJCQlnb3RvIGRvX3NpZ2J1czsKIAkJQlVHKCk7CmRpZmYgLS1naXQgYS9hcmNoL3NwYXJjL25ldC9icGZfaml0X2NvbXAuYyBiL2FyY2gvc3BhcmMvbmV0L2JwZl9qaXRfY29tcC5jCmluZGV4IGYzM2U3YzcuLjc5MzFlZWUgMTAwNjQ0Ci0tLSBhL2FyY2gvc3BhcmMvbmV0L2JwZl9qaXRfY29tcC5jCisrKyBiL2FyY2gvc3BhcmMvbmV0L2JwZl9qaXRfY29tcC5jCkBAIC03NzYsNyArNzc2LDcgQEAKIAkJCQlpZiAodW5saWtlbHkocHJvZ2xlbiArIGlsZW4gPiBvbGRwcm9nbGVuKSkgewogCQkJCQlwcl9lcnIoImJwYl9qaXRfY29tcGlsZSBmYXRhbCBlcnJvclxuIik7CiAJCQkJCWtmcmVlKGFkZHJzKTsKLQkJCQkJbW9kdWxlX2ZyZWUoTlVMTCwgaW1hZ2UpOworCQkJCQltb2R1bGVfbWVtZnJlZShpbWFnZSk7CiAJCQkJCXJldHVybjsKIAkJCQl9CiAJCQkJbWVtY3B5KGltYWdlICsgcHJvZ2xlbiwgdGVtcCwgaWxlbik7CkBAIC04MjIsNyArODIyLDcgQEAKIHZvaWQgYnBmX2ppdF9mcmVlKHN0cnVjdCBicGZfcHJvZyAqZnApCiB7CiAJaWYgKGZwLT5qaXRlZCkKLQkJbW9kdWxlX2ZyZWUoTlVMTCwgZnAtPmJwZl9mdW5jKTsKKwkJbW9kdWxlX21lbWZyZWUoZnAtPmJwZl9mdW5jKTsKIAogCWJwZl9wcm9nX3VubG9ja19mcmVlKGZwKTsKIH0KZGlmZiAtLWdpdCBhL2FyY2gvdGlsZS9rZXJuZWwvbW9kdWxlLmMgYi9hcmNoL3RpbGUva2VybmVsL21vZHVsZS5jCmluZGV4IDk2NDQ3YzkuLjIzMDUwODQgMTAwNjQ0Ci0tLSBhL2FyY2gvdGlsZS9rZXJuZWwvbW9kdWxlLmMKKysrIGIvYXJjaC90aWxlL2tlcm5lbC9tb2R1bGUuYwpAQCAtNzQsNyArNzQsNyBAQAogCiAKIC8qIEZyZWUgbWVtb3J5IHJldHVybmVkIGZyb20gbW9kdWxlX2FsbG9jICovCi12b2lkIG1vZHVsZV9mcmVlKHN0cnVjdCBtb2R1bGUgKm1vZCwgdm9pZCAqbW9kdWxlX3JlZ2lvbikKK3ZvaWQgbW9kdWxlX21lbWZyZWUodm9pZCAqbW9kdWxlX3JlZ2lvbikKIHsKIAl2ZnJlZShtb2R1bGVfcmVnaW9uKTsKIApAQCAtODMsNyArODMsNyBAQAogCQkgICAgIDAsIDAsIDAsIE5VTEwsIE5VTEwsIDApOwogCiAJLyoKLQkgKiBGSVhNRTogSWYgbW9kdWxlX3JlZ2lvbiA9PSBtb2QtPm1vZHVsZV9pbml0LCB0cmltIGV4Y2VwdGlvbgorCSAqIEZJWE1FOiBBZGQgbW9kdWxlX2FyY2hfZnJlZWluZ19pbml0IHRvIHRyaW0gZXhjZXB0aW9uCiAJICogdGFibGUgZW50cmllcy4KIAkgKi8KIH0KZGlmZiAtLWdpdCBhL2FyY2gvdGlsZS9tbS9mYXVsdC5jIGIvYXJjaC90aWxlL21tL2ZhdWx0LmMKaW5kZXggNTY1ZTI1YS4uMGY2MWE3MyAxMDA2NDQKLS0tIGEvYXJjaC90aWxlL21tL2ZhdWx0LmMKKysrIGIvYXJjaC90aWxlL21tL2ZhdWx0LmMKQEAgLTQ0Miw2ICs0NDIsOCBAQAogCWlmICh1bmxpa2VseShmYXVsdCAmIFZNX0ZBVUxUX0VSUk9SKSkgewogCQlpZiAoZmF1bHQgJiBWTV9GQVVMVF9PT00pCiAJCQlnb3RvIG91dF9vZl9tZW1vcnk7CisJCWVsc2UgaWYgKGZhdWx0ICYgVk1fRkFVTFRfU0lHU0VHVikKKwkJCWdvdG8gYmFkX2FyZWE7CiAJCWVsc2UgaWYgKGZhdWx0ICYgVk1fRkFVTFRfU0lHQlVTKQogCQkJZ290byBkb19zaWdidXM7CiAJCUJVRygpOwpkaWZmIC0tZ2l0IGEvYXJjaC91bS9rZXJuZWwvdHJhcC5jIGIvYXJjaC91bS9rZXJuZWwvdHJhcC5jCmluZGV4IDU2NzhjMzUuLjIwOTYxNzMgMTAwNjQ0Ci0tLSBhL2FyY2gvdW0va2VybmVsL3RyYXAuYworKysgYi9hcmNoL3VtL2tlcm5lbC90cmFwLmMKQEAgLTgwLDYgKzgwLDggQEAKIAkJaWYgKHVubGlrZWx5KGZhdWx0ICYgVk1fRkFVTFRfRVJST1IpKSB7CiAJCQlpZiAoZmF1bHQgJiBWTV9GQVVMVF9PT00pIHsKIAkJCQlnb3RvIG91dF9vZl9tZW1vcnk7CisJCQl9IGVsc2UgaWYgKGZhdWx0ICYgVk1fRkFVTFRfU0lHU0VHVikgeworCQkJCWdvdG8gb3V0OwogCQkJfSBlbHNlIGlmIChmYXVsdCAmIFZNX0ZBVUxUX1NJR0JVUykgewogCQkJCWVyciA9IC1FQUNDRVM7CiAJCQkJZ290byBvdXQ7CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9LY29uZmlnIGIvYXJjaC94ODYvS2NvbmZpZwppbmRleCBiYTM5N2JkLi4zZTE1Y2VlIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9LY29uZmlnCisrKyBiL2FyY2gveDg2L0tjb25maWcKQEAgLTQ5Niw2ICs0OTYsMTcgQEAKIAkgIHRoaW5ncyBsaWtlIGNsb2NrIHRyZWUgKGNvbW1vbiBjbG9jayBmcmFtZXdvcmspIGFuZCBwaW5jb250cm9sCiAJICB3aGljaCBhcmUgbmVlZGVkIGJ5IHRoZSBMUFNTIHBlcmlwaGVyYWwgZHJpdmVycy4KIAorY29uZmlnIFg4Nl9BTURfUExBVEZPUk1fREVWSUNFCisJYm9vbCAiQU1EIEFDUEkyUGxhdGZvcm0gZGV2aWNlcyBzdXBwb3J0IgorCWRlcGVuZHMgb24gQUNQSQorCXNlbGVjdCBDT01NT05fQ0xLCisJc2VsZWN0IFBJTkNUUkwKKwktLS1oZWxwLS0tCisJICBTZWxlY3QgdG8gaW50ZXJwcmV0IEFNRCBzcGVjaWZpYyBBQ1BJIGRldmljZSB0byBwbGF0Zm9ybSBkZXZpY2UKKwkgIHN1Y2ggYXMgSTJDLCBVQVJULCBHUElPIGZvdW5kIG9uIEFNRCBDYXJyaXpvIGFuZCBsYXRlciBjaGlwc2V0cy4KKwkgIEkyQyBhbmQgVUFSVCBkZXBlbmQgb24gQ09NTU9OX0NMSyB0byBzZXQgY2xvY2suIEdQSU8gZHJpdmVyIGlzCisJICBpbXBsZW1lbnRlZCB1bmRlciBQSU5DVFJMIHN1YnN5c3RlbS4KKwogY29uZmlnIElPU0ZfTUJJCiAJdHJpc3RhdGUgIkludGVsIFNvQyBJT1NGIFNpZGViYW5kIHN1cHBvcnQgZm9yIFNvQyBwbGF0Zm9ybXMiCiAJZGVwZW5kcyBvbiBQQ0kKQEAgLTg1Nyw3ICs4NjgsNyBAQAogCiBjb25maWcgWDg2X1VQX0FQSUMKIAlib29sICJMb2NhbCBBUElDIHN1cHBvcnQgb24gdW5pcHJvY2Vzc29ycyIKLQlkZXBlbmRzIG9uIFg4Nl8zMiAmJiAhU01QICYmICFYODZfMzJfTk9OX1NUQU5EQVJEICYmICFQQ0lfTVNJCisJZGVwZW5kcyBvbiBYODZfMzIgJiYgIVNNUCAmJiAhWDg2XzMyX05PTl9TVEFOREFSRAogCS0tLWhlbHAtLS0KIAkgIEEgbG9jYWwgQVBJQyAoQWR2YW5jZWQgUHJvZ3JhbW1hYmxlIEludGVycnVwdCBDb250cm9sbGVyKSBpcyBhbgogCSAgaW50ZWdyYXRlZCBpbnRlcnJ1cHQgY29udHJvbGxlciBpbiB0aGUgQ1BVLiBJZiB5b3UgaGF2ZSBhIHNpbmdsZS1DUFUKQEAgLTg2OCw2ICs4NzksMTAgQEAKIAkgIHBlcmZvcm1hbmNlIGNvdW50ZXJzKSwgYW5kIHRoZSBOTUkgd2F0Y2hkb2cgd2hpY2ggZGV0ZWN0cyBoYXJkCiAJICBsb2NrdXBzLgogCitjb25maWcgWDg2X1VQX0FQSUNfTVNJCisJZGVmX2Jvb2wgeQorCXNlbGVjdCBYODZfVVBfQVBJQyBpZiBYODZfMzIgJiYgIVNNUCAmJiAhWDg2XzMyX05PTl9TVEFOREFSRCAmJiBQQ0lfTVNJCisKIGNvbmZpZyBYODZfVVBfSU9BUElDCiAJYm9vbCAiSU8tQVBJQyBzdXBwb3J0IG9uIHVuaXByb2Nlc3NvcnMiCiAJZGVwZW5kcyBvbiBYODZfVVBfQVBJQwpkaWZmIC0tZ2l0IGEvYXJjaC94ODYvYm9vdC9jb21wcmVzc2VkL01ha2VmaWxlIGIvYXJjaC94ODYvYm9vdC9jb21wcmVzc2VkL01ha2VmaWxlCmluZGV4IGQ5OTkzOTguLmFkNzU0YjQgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2Jvb3QvY29tcHJlc3NlZC9NYWtlZmlsZQorKysgYi9hcmNoL3g4Ni9ib290L2NvbXByZXNzZWQvTWFrZWZpbGUKQEAgLTkwLDcgKzkwLDcgQEAKIHN1ZmZpeC0kKENPTkZJR19LRVJORUxfTFo0KSAJOj0gbHo0CiAKIFJVTl9TSVpFID0gJChzaGVsbCAkKE9CSkRVTVApIC1oIHZtbGludXggfCBcCi0JICAgICBwZXJsICQoc3JjdHJlZSkvYXJjaC94ODYvdG9vbHMvY2FsY19ydW5fc2l6ZS5wbCkKKwkgICAgICQoQ09ORklHX1NIRUxMKSAkKHNyY3RyZWUpL2FyY2gveDg2L3Rvb2xzL2NhbGNfcnVuX3NpemUuc2gpCiBxdWlldF9jbWRfbWtwaWdneSA9IE1LUElHR1kgJEAKICAgICAgIGNtZF9ta3BpZ2d5ID0gJChvYmopL21rcGlnZ3kgJDwgJChSVU5fU0laRSkgPiAkQCB8fCAoIHJtIC1mICRAIDsgZmFsc2UgKQogCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9ib290L2NvbXByZXNzZWQvbWlzYy5jIGIvYXJjaC94ODYvYm9vdC9jb21wcmVzc2VkL21pc2MuYwppbmRleCBkY2MxYzUzLi5hOTUwODY0IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9ib290L2NvbXByZXNzZWQvbWlzYy5jCisrKyBiL2FyY2gveDg2L2Jvb3QvY29tcHJlc3NlZC9taXNjLmMKQEAgLTM3Myw2ICszNzMsOCBAQAogCQkJCSAgdW5zaWduZWQgbG9uZyBvdXRwdXRfbGVuLAogCQkJCSAgdW5zaWduZWQgbG9uZyBydW5fc2l6ZSkKIHsKKwl1bnNpZ25lZCBjaGFyICpvdXRwdXRfb3JpZyA9IG91dHB1dDsKKwogCXJlYWxfbW9kZSA9IHJtb2RlOwogCiAJc2FuaXRpemVfYm9vdF9wYXJhbXMocmVhbF9tb2RlKTsKQEAgLTQyMSw3ICs0MjMsMTIgQEAKIAlkZWJ1Z19wdXRzdHIoIlxuRGVjb21wcmVzc2luZyBMaW51eC4uLiAiKTsKIAlkZWNvbXByZXNzKGlucHV0X2RhdGEsIGlucHV0X2xlbiwgTlVMTCwgTlVMTCwgb3V0cHV0LCBOVUxMLCBlcnJvcik7CiAJcGFyc2VfZWxmKG91dHB1dCk7Ci0JaGFuZGxlX3JlbG9jYXRpb25zKG91dHB1dCwgb3V0cHV0X2xlbik7CisJLyoKKwkgKiAzMi1iaXQgYWx3YXlzIHBlcmZvcm1zIHJlbG9jYXRpb25zLiA2NC1iaXQgcmVsb2NhdGlvbnMgYXJlIG9ubHkKKwkgKiBuZWVkZWQgaWYga0FTTFIgaGFzIGNob3NlbiBhIGRpZmZlcmVudCBsb2FkIGFkZHJlc3MuCisJICovCisJaWYgKCFJU19FTkFCTEVEKENPTkZJR19YODZfNjQpIHx8IG91dHB1dCAhPSBvdXRwdXRfb3JpZykKKwkJaGFuZGxlX3JlbG9jYXRpb25zKG91dHB1dCwgb3V0cHV0X2xlbik7CiAJZGVidWdfcHV0c3RyKCJkb25lLlxuQm9vdGluZyB0aGUga2VybmVsLlxuIik7CiAJcmV0dXJuIG91dHB1dDsKIH0KZGlmZiAtLWdpdCBhL2FyY2gveDg2L2NyeXB0by9zaGEtbWIvc2hhMV9tYi5jIGIvYXJjaC94ODYvY3J5cHRvL3NoYS1tYi9zaGExX21iLmMKaW5kZXggYTIyNWE1Y2EuLmZkOWY2YjAgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2NyeXB0by9zaGEtbWIvc2hhMV9tYi5jCisrKyBiL2FyY2gveDg2L2NyeXB0by9zaGEtbWIvc2hhMV9tYi5jCkBAIC05MzEsNCArOTMxLDQgQEAKIE1PRFVMRV9MSUNFTlNFKCJHUEwiKTsKIE1PRFVMRV9ERVNDUklQVElPTigiU0hBMSBTZWN1cmUgSGFzaCBBbGdvcml0aG0sIG11bHRpIGJ1ZmZlciBhY2NlbGVyYXRlZCIpOwogCi1NT0RVTEVfQUxJQVMoInNoYTEiKTsKK01PRFVMRV9BTElBU19DUllQVE8oInNoYTEiKTsKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL2FjcGkuaCBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL2FjcGkuaAppbmRleCAwYWI0ZjlmLi4zYTQ1NjY4IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9hY3BpLmgKKysrIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vYWNwaS5oCkBAIC01MCw2ICs1MCw3IEBACiAKIGV4dGVybiBpbnQgKCpfX2FjcGlfcmVnaXN0ZXJfZ3NpKShzdHJ1Y3QgZGV2aWNlICpkZXYsIHUzMiBnc2ksCiAJCQkJICBpbnQgdHJpZ2dlciwgaW50IHBvbGFyaXR5KTsKK2V4dGVybiB2b2lkICgqX19hY3BpX3VucmVnaXN0ZXJfZ3NpKSh1MzIgZ3NpKTsKIAogc3RhdGljIGlubGluZSB2b2lkIGRpc2FibGVfYWNwaSh2b2lkKQogewpkaWZmIC0tZ2l0IGEvYXJjaC94ODYvaW5jbHVkZS9hc20vZGVzYy5oIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vZGVzYy5oCmluZGV4IDUwZDAzM2EuLmE5NGI4MmUgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL2Rlc2MuaAorKysgYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9kZXNjLmgKQEAgLTI1MSw3ICsyNTEsOCBAQAogCQlnZHRbR0RUX0VOVFJZX1RMU19NSU4gKyBpXSA9IHQtPnRsc19hcnJheVtpXTsKIH0KIAotI2RlZmluZSBfTERUX2VtcHR5KGluZm8pCQkJCVwKKy8qIFRoaXMgaW50ZW50aW9uYWxseSBpZ25vcmVzIGxtLCBzaW5jZSAzMi1iaXQgYXBwcyBkb24ndCBoYXZlIHRoYXQgZmllbGQuICovCisjZGVmaW5lIExEVF9lbXB0eShpbmZvKQkJCQkJXAogCSgoaW5mbyktPmJhc2VfYWRkcgkJPT0gMAkmJglcCiAJIChpbmZvKS0+bGltaXQJCQk9PSAwCSYmCVwKIAkgKGluZm8pLT5jb250ZW50cwkJPT0gMAkmJglcCkBAIC0yNjEsMTEgKzI2MiwxOCBAQAogCSAoaW5mbyktPnNlZ19ub3RfcHJlc2VudAk9PSAxCSYmCVwKIAkgKGluZm8pLT51c2VhYmxlCQk9PSAwKQogCi0jaWZkZWYgQ09ORklHX1g4Nl82NAotI2RlZmluZSBMRFRfZW1wdHkoaW5mbykgKF9MRFRfZW1wdHkoaW5mbykgJiYgKChpbmZvKS0+bG0gPT0gMCkpCi0jZWxzZQotI2RlZmluZSBMRFRfZW1wdHkoaW5mbykgKF9MRFRfZW1wdHkoaW5mbykpCi0jZW5kaWYKKy8qIExvdHMgb2YgcHJvZ3JhbXMgZXhwZWN0IGFuIGFsbC16ZXJvIHVzZXJfZGVzYyB0byBtZWFuICJubyBzZWdtZW50IGF0IGFsbCIuICovCitzdGF0aWMgaW5saW5lIGJvb2wgTERUX3plcm8oY29uc3Qgc3RydWN0IHVzZXJfZGVzYyAqaW5mbykKK3sKKwlyZXR1cm4gKGluZm8tPmJhc2VfYWRkcgkJPT0gMCAmJgorCQlpbmZvLT5saW1pdAkJPT0gMCAmJgorCQlpbmZvLT5jb250ZW50cwkJPT0gMCAmJgorCQlpbmZvLT5yZWFkX2V4ZWNfb25seQk9PSAwICYmCisJCWluZm8tPnNlZ18zMmJpdAkJPT0gMCAmJgorCQlpbmZvLT5saW1pdF9pbl9wYWdlcwk9PSAwICYmCisJCWluZm8tPnNlZ19ub3RfcHJlc2VudAk9PSAwICYmCisJCWluZm8tPnVzZWFibGUJCT09IDApOworfQogCiBzdGF0aWMgaW5saW5lIHZvaWQgY2xlYXJfTERUKHZvaWQpCiB7CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9tbXVfY29udGV4dC5oIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vbW11X2NvbnRleHQuaAppbmRleCA0MDI2OWEyLi40Yjc1ZDU5IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9tbXVfY29udGV4dC5oCisrKyBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL21tdV9jb250ZXh0LmgKQEAgLTEzMCw3ICsxMzAsMjUgQEAKIHN0YXRpYyBpbmxpbmUgdm9pZCBhcmNoX3VubWFwKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKIAkJCSAgICAgIHVuc2lnbmVkIGxvbmcgc3RhcnQsIHVuc2lnbmVkIGxvbmcgZW5kKQogewotCW1weF9ub3RpZnlfdW5tYXAobW0sIHZtYSwgc3RhcnQsIGVuZCk7CisJLyoKKwkgKiBtcHhfbm90aWZ5X3VubWFwKCkgZ29lcyBhbmQgcmVhZHMgYSByYXJlbHktaG90CisJICogY2FjaGVsaW5lIGluIHRoZSBtbV9zdHJ1Y3QuICBUaGF0IGNhbiBiZSBleHBlbnNpdmUKKwkgKiBlbm91Z2ggdG8gYmUgc2VlbiBpbiBwcm9maWxlcy4KKwkgKgorCSAqIFRoZSBtcHhfbm90aWZ5X3VubWFwKCkgY2FsbCBhbmQgaXRzIGNvbnRlbnRzIGhhdmUgYmVlbgorCSAqIG9ic2VydmVkIHRvIGFmZmVjdCBtdW5tYXAoKSBwZXJmb3JtYW5jZSBvbiBoYXJkd2FyZQorCSAqIHdoZXJlIE1QWCBpcyBub3QgcHJlc2VudC4KKwkgKgorCSAqIFRoZSB1bmxpa2VseSgpIG9wdGltaXplcyBmb3IgdGhlIGZhc3QgY2FzZTogbm8gTVBYCisJICogaW4gdGhlIENQVSwgb3Igbm8gTVBYIHVzZSBpbiB0aGUgcHJvY2Vzcy4gIEV2ZW4gaWYKKwkgKiB3ZSBnZXQgdGhpcyB3cm9uZyAoaW4gdGhlIHVubGlrZWx5IGV2ZW50IHRoYXQgTVBYCisJICogaXMgd2lkZWx5IGVuYWJsZWQgb24gc29tZSBzeXN0ZW0pIHRoZSBvdmVyaGVhZCBvZgorCSAqIE1QWCBpdHNlbGYgKHJlYWRpbmcgYm91bmRzIHRhYmxlcykgaXMgZXhwZWN0ZWQgdG8KKwkgKiBvdmVyd2hlbG0gdGhlIG92ZXJoZWFkIG9mIGdldHRpbmcgdGhpcyB1bmxpa2VseSgpCisJICogY29uc2lzdGVudGx5IHdyb25nLgorCSAqLworCWlmICh1bmxpa2VseShjcHVfZmVhdHVyZV9lbmFibGVkKFg4Nl9GRUFUVVJFX01QWCkpKQorCQltcHhfbm90aWZ5X3VubWFwKG1tLCB2bWEsIHN0YXJ0LCBlbmQpOwogfQogCiAjZW5kaWYgLyogX0FTTV9YODZfTU1VX0NPTlRFWFRfSCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC94ODYvaW5jbHVkZS9hc20vcGNpX3g4Ni5oIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vcGNpX3g4Ni5oCmluZGV4IDE2NGUzZjguLmZhMTE5NWQgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL3BjaV94ODYuaAorKysgYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9wY2lfeDg2LmgKQEAgLTkzLDggKzkzLDYgQEAKIGV4dGVybiBpbnQgKCpwY2liaW9zX2VuYWJsZV9pcnEpKHN0cnVjdCBwY2lfZGV2ICpkZXYpOwogZXh0ZXJuIHZvaWQgKCpwY2liaW9zX2Rpc2FibGVfaXJxKShzdHJ1Y3QgcGNpX2RldiAqZGV2KTsKIAotZXh0ZXJuIGJvb2wgbXBfc2hvdWxkX2tlZXBfaXJxKHN0cnVjdCBkZXZpY2UgKmRldik7Ci0KIHN0cnVjdCBwY2lfcmF3X29wcyB7CiAJaW50ICgqcmVhZCkodW5zaWduZWQgaW50IGRvbWFpbiwgdW5zaWduZWQgaW50IGJ1cywgdW5zaWduZWQgaW50IGRldmZuLAogCQkJCQkJaW50IHJlZywgaW50IGxlbiwgdTMyICp2YWwpOwpkaWZmIC0tZ2l0IGEvYXJjaC94ODYva2VybmVsL2FjcGkvYm9vdC5jIGIvYXJjaC94ODYva2VybmVsL2FjcGkvYm9vdC5jCmluZGV4IGQxNjI2MzYuLjE0ZDM2NTIgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2tlcm5lbC9hY3BpL2Jvb3QuYworKysgYi9hcmNoL3g4Ni9rZXJuZWwvYWNwaS9ib290LmMKQEAgLTYxMSwyMCArNjExLDIwIEBACiAKIGludCBhY3BpX2dzaV90b19pcnEodTMyIGdzaSwgdW5zaWduZWQgaW50ICppcnFwKQogewotCWludCBpcnE7CisJaW50IHJjLCBpcnEsIHRyaWdnZXIsIHBvbGFyaXR5OwogCi0JaWYgKGFjcGlfaXJxX21vZGVsID09IEFDUElfSVJRX01PREVMX1BJQykgewotCQkqaXJxcCA9IGdzaTsKLQl9IGVsc2UgewotCQltdXRleF9sb2NrKCZhY3BpX2lvYXBpY19sb2NrKTsKLQkJaXJxID0gbXBfbWFwX2dzaV90b19pcnEoZ3NpLAotCQkJCQlJT0FQSUNfTUFQX0FMTE9DIHwgSU9BUElDX01BUF9DSEVDSyk7Ci0JCW11dGV4X3VubG9jaygmYWNwaV9pb2FwaWNfbG9jayk7Ci0JCWlmIChpcnEgPCAwKQotCQkJcmV0dXJuIC0xOwotCQkqaXJxcCA9IGlycTsKKwlyYyA9IGFjcGlfZ2V0X292ZXJyaWRlX2lycShnc2ksICZ0cmlnZ2VyLCAmcG9sYXJpdHkpOworCWlmIChyYyA9PSAwKSB7CisJCXRyaWdnZXIgPSB0cmlnZ2VyID8gQUNQSV9MRVZFTF9TRU5TSVRJVkUgOiBBQ1BJX0VER0VfU0VOU0lUSVZFOworCQlwb2xhcml0eSA9IHBvbGFyaXR5ID8gQUNQSV9BQ1RJVkVfTE9XIDogQUNQSV9BQ1RJVkVfSElHSDsKKwkJaXJxID0gYWNwaV9yZWdpc3Rlcl9nc2koTlVMTCwgZ3NpLCB0cmlnZ2VyLCBwb2xhcml0eSk7CisJCWlmIChpcnEgPj0gMCkgeworCQkJKmlycXAgPSBpcnE7CisJCQlyZXR1cm4gMDsKKwkJfQogCX0KLQlyZXR1cm4gMDsKKworCXJldHVybiAtMTsKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKGFjcGlfZ3NpX3RvX2lycSk7CiAKQEAgLTg0MywxMyArODQzLDcgQEAKIAogc3RhdGljIGludCBfX2luaXQgYWNwaV9wYXJzZV9zYmYoc3RydWN0IGFjcGlfdGFibGVfaGVhZGVyICp0YWJsZSkKIHsKLQlzdHJ1Y3QgYWNwaV90YWJsZV9ib290ICpzYjsKLQotCXNiID0gKHN0cnVjdCBhY3BpX3RhYmxlX2Jvb3QgKil0YWJsZTsKLQlpZiAoIXNiKSB7Ci0JCXByaW50ayhLRVJOX1dBUk5JTkcgUFJFRklYICJVbmFibGUgdG8gbWFwIFNCRlxuIik7Ci0JCXJldHVybiAtRU5PREVWOwotCX0KKwlzdHJ1Y3QgYWNwaV90YWJsZV9ib290ICpzYiA9IChzdHJ1Y3QgYWNwaV90YWJsZV9ib290ICopdGFibGU7CiAKIAlzYmZfcG9ydCA9IHNiLT5jbW9zX2luZGV4OwkvKiBTYXZlIENNT1MgcG9ydCAqLwogCkBAIC04NjMsMTMgKzg1Nyw3IEBACiAKIHN0YXRpYyBpbnQgX19pbml0IGFjcGlfcGFyc2VfaHBldChzdHJ1Y3QgYWNwaV90YWJsZV9oZWFkZXIgKnRhYmxlKQogewotCXN0cnVjdCBhY3BpX3RhYmxlX2hwZXQgKmhwZXRfdGJsOwotCi0JaHBldF90YmwgPSAoc3RydWN0IGFjcGlfdGFibGVfaHBldCAqKXRhYmxlOwotCWlmICghaHBldF90YmwpIHsKLQkJcHJpbnRrKEtFUk5fV0FSTklORyBQUkVGSVggIlVuYWJsZSB0byBtYXAgSFBFVFxuIik7Ci0JCXJldHVybiAtRU5PREVWOwotCX0KKwlzdHJ1Y3QgYWNwaV90YWJsZV9ocGV0ICpocGV0X3RibCA9IChzdHJ1Y3QgYWNwaV90YWJsZV9ocGV0ICopdGFibGU7CiAKIAlpZiAoaHBldF90YmwtPmFkZHJlc3Muc3BhY2VfaWQgIT0gQUNQSV9TUEFDRV9NRU0pIHsKIAkJcHJpbnRrKEtFUk5fV0FSTklORyBQUkVGSVggIkhQRVQgdGltZXJzIG11c3QgYmUgbG9jYXRlZCBpbiAiCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9rZXJuZWwvY3B1L21pY3JvY29kZS9jb3JlLmMgYi9hcmNoL3g4Ni9rZXJuZWwvY3B1L21pY3JvY29kZS9jb3JlLmMKaW5kZXggMTVjMjkwOS4uMzZhODM2MSAxMDA2NDQKLS0tIGEvYXJjaC94ODYva2VybmVsL2NwdS9taWNyb2NvZGUvY29yZS5jCisrKyBiL2FyY2gveDg2L2tlcm5lbC9jcHUvbWljcm9jb2RlL2NvcmUuYwpAQCAtNTUyLDcgKzU1Miw3IEBACiAJaW50IGVycm9yOwogCiAJaWYgKHBhcmF2aXJ0X2VuYWJsZWQoKSB8fCBkaXNfdWNvZGVfbGRyKQotCQlyZXR1cm4gMDsKKwkJcmV0dXJuIC1FSU5WQUw7CiAKIAlpZiAoYy0+eDg2X3ZlbmRvciA9PSBYODZfVkVORE9SX0lOVEVMKQogCQltaWNyb2NvZGVfb3BzID0gaW5pdF9pbnRlbF9taWNyb2NvZGUoKTsKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC9jcHUvbXNoeXBlcnYuYyBiL2FyY2gveDg2L2tlcm5lbC9jcHUvbXNoeXBlcnYuYwppbmRleCBhNDUwMzczLi45MzkxNTVmIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvY3B1L21zaHlwZXJ2LmMKKysrIGIvYXJjaC94ODYva2VybmVsL2NwdS9tc2h5cGVydi5jCkBAIC0xMDcsNiArMTA3LDcgQEAKIAkucmF0aW5nCQk9IDQwMCwgLyogdXNlIHRoaXMgd2hlbiBydW5uaW5nIG9uIEh5cGVydiovCiAJLnJlYWQJCT0gcmVhZF9odl9jbG9jaywKIAkubWFzawkJPSBDTE9DS1NPVVJDRV9NQVNLKDY0KSwKKwkuZmxhZ3MJCT0gQ0xPQ0tfU09VUkNFX0lTX0NPTlRJTlVPVVMsCiB9OwogCiBzdGF0aWMgdm9pZCBfX2luaXQgbXNfaHlwZXJ2X2luaXRfcGxhdGZvcm0odm9pZCkKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC9jcHUvcGVyZl9ldmVudF9pbnRlbC5jIGIvYXJjaC94ODYva2VybmVsL2NwdS9wZXJmX2V2ZW50X2ludGVsLmMKaW5kZXggOTQ0YmYwMS4uNDk4YjZkOSAxMDA2NDQKLS0tIGEvYXJjaC94ODYva2VybmVsL2NwdS9wZXJmX2V2ZW50X2ludGVsLmMKKysrIGIvYXJjaC94ODYva2VybmVsL2NwdS9wZXJmX2V2ZW50X2ludGVsLmMKQEAgLTI0MzEsNiArMjQzMSw3IEBACiAJCWJyZWFrOwogCiAJY2FzZSA1NTogLyogMjJubSBBdG9tICJTaWx2ZXJtb250IiAgICAgICAgICAgICAgICAqLworCWNhc2UgNzY6IC8qIDE0bm0gQXRvbSAiQWlybW9udCIgICAgICAgICAgICAgICAgICAgKi8KIAljYXNlIDc3OiAvKiAyMm5tIEF0b20gIlNpbHZlcm1vbnQgQXZvdG9uL1JhbmdlbHkiICovCiAJCW1lbWNweShod19jYWNoZV9ldmVudF9pZHMsIHNsbV9od19jYWNoZV9ldmVudF9pZHMsCiAJCQlzaXplb2YoaHdfY2FjaGVfZXZlbnRfaWRzKSk7CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9rZXJuZWwvY3B1L3BlcmZfZXZlbnRfaW50ZWxfcmFwbC5jIGIvYXJjaC94ODYva2VybmVsL2NwdS9wZXJmX2V2ZW50X2ludGVsX3JhcGwuYwppbmRleCA2ZTQzNGY4Li5jNGJiOGI4IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvY3B1L3BlcmZfZXZlbnRfaW50ZWxfcmFwbC5jCisrKyBiL2FyY2gveDg2L2tlcm5lbC9jcHUvcGVyZl9ldmVudF9pbnRlbF9yYXBsLmMKQEAgLTE0Miw3ICsxNDIsNyBAQAogCSAqIG9yIHVzZSBsZGV4cChjb3VudCwgLTMyKS4KIAkgKiBXYXR0cyA9IEpvdWxlcy9UaW1lIGRlbHRhCiAJICovCi0JcmV0dXJuIHYgPDwgKDMyIC0gX190aGlzX2NwdV9yZWFkKHJhcGxfcG11LT5od191bml0KSk7CisJcmV0dXJuIHYgPDwgKDMyIC0gX190aGlzX2NwdV9yZWFkKHJhcGxfcG11KS0+aHdfdW5pdCk7CiB9CiAKIHN0YXRpYyB1NjQgcmFwbF9ldmVudF91cGRhdGUoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQpkaWZmIC0tZ2l0IGEvYXJjaC94ODYva2VybmVsL2NwdS9wZXJmX2V2ZW50X2ludGVsX3VuY29yZS5jIGIvYXJjaC94ODYva2VybmVsL2NwdS9wZXJmX2V2ZW50X2ludGVsX3VuY29yZS5jCmluZGV4IDEwYjhkM2UuLmM2MzViOGIgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2tlcm5lbC9jcHUvcGVyZl9ldmVudF9pbnRlbF91bmNvcmUuYworKysgYi9hcmNoL3g4Ni9rZXJuZWwvY3B1L3BlcmZfZXZlbnRfaW50ZWxfdW5jb3JlLmMKQEAgLTg0MCw3ICs4NDAsNiBAQAogCWJveC0+cGh5c19pZCA9IHBoeXNfaWQ7CiAJYm94LT5wY2lfZGV2ID0gcGRldjsKIAlib3gtPnBtdSA9IHBtdTsKLQl1bmNvcmVfYm94X2luaXQoYm94KTsKIAlwY2lfc2V0X2RydmRhdGEocGRldiwgYm94KTsKIAogCXJhd19zcGluX2xvY2soJnVuY29yZV9ib3hfbG9jayk7CkBAIC0xMDA0LDEwICsxMDAzLDggQEAKIAkJCXBtdSA9ICZ0eXBlLT5wbXVzW2pdOwogCQkJYm94ID0gKnBlcl9jcHVfcHRyKHBtdS0+Ym94LCBjcHUpOwogCQkJLyogY2FsbGVkIGJ5IHVuY29yZV9jcHVfaW5pdD8gKi8KLQkJCWlmIChib3ggJiYgYm94LT5waHlzX2lkID49IDApIHsKLQkJCQl1bmNvcmVfYm94X2luaXQoYm94KTsKKwkJCWlmIChib3ggJiYgYm94LT5waHlzX2lkID49IDApCiAJCQkJY29udGludWU7Ci0JCQl9CiAKIAkJCWZvcl9lYWNoX29ubGluZV9jcHUoaykgewogCQkJCWV4aXN0ID0gKnBlcl9jcHVfcHRyKHBtdS0+Ym94LCBrKTsKQEAgLTEwMjMsMTAgKzEwMjAsOCBAQAogCQkJCX0KIAkJCX0KIAotCQkJaWYgKGJveCkgeworCQkJaWYgKGJveCkKIAkJCQlib3gtPnBoeXNfaWQgPSBwaHlzX2lkOwotCQkJCXVuY29yZV9ib3hfaW5pdChib3gpOwotCQkJfQogCQl9CiAJfQogCXJldHVybiAwOwpkaWZmIC0tZ2l0IGEvYXJjaC94ODYva2VybmVsL2NwdS9wZXJmX2V2ZW50X2ludGVsX3VuY29yZS5oIGIvYXJjaC94ODYva2VybmVsL2NwdS9wZXJmX2V2ZW50X2ludGVsX3VuY29yZS5oCmluZGV4IDg2M2Q5YjAuLjZjOGMxZTcgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2tlcm5lbC9jcHUvcGVyZl9ldmVudF9pbnRlbF91bmNvcmUuaAorKysgYi9hcmNoL3g4Ni9rZXJuZWwvY3B1L3BlcmZfZXZlbnRfaW50ZWxfdW5jb3JlLmgKQEAgLTI1Nyw2ICsyNTcsMTQgQEAKIAlyZXR1cm4gYm94LT5wbXUtPnR5cGUtPm51bV9jb3VudGVyczsKIH0KIAorc3RhdGljIGlubGluZSB2b2lkIHVuY29yZV9ib3hfaW5pdChzdHJ1Y3QgaW50ZWxfdW5jb3JlX2JveCAqYm94KQoreworCWlmICghdGVzdF9hbmRfc2V0X2JpdChVTkNPUkVfQk9YX0ZMQUdfSU5JVElBVEVELCAmYm94LT5mbGFncykpIHsKKwkJaWYgKGJveC0+cG11LT50eXBlLT5vcHMtPmluaXRfYm94KQorCQkJYm94LT5wbXUtPnR5cGUtPm9wcy0+aW5pdF9ib3goYm94KTsKKwl9Cit9CisKIHN0YXRpYyBpbmxpbmUgdm9pZCB1bmNvcmVfZGlzYWJsZV9ib3goc3RydWN0IGludGVsX3VuY29yZV9ib3ggKmJveCkKIHsKIAlpZiAoYm94LT5wbXUtPnR5cGUtPm9wcy0+ZGlzYWJsZV9ib3gpCkBAIC0yNjUsNiArMjczLDggQEAKIAogc3RhdGljIGlubGluZSB2b2lkIHVuY29yZV9lbmFibGVfYm94KHN0cnVjdCBpbnRlbF91bmNvcmVfYm94ICpib3gpCiB7CisJdW5jb3JlX2JveF9pbml0KGJveCk7CisKIAlpZiAoYm94LT5wbXUtPnR5cGUtPm9wcy0+ZW5hYmxlX2JveCkKIAkJYm94LT5wbXUtPnR5cGUtPm9wcy0+ZW5hYmxlX2JveChib3gpOwogfQpAQCAtMjg3LDE0ICsyOTcsNiBAQAogCXJldHVybiBib3gtPnBtdS0+dHlwZS0+b3BzLT5yZWFkX2NvdW50ZXIoYm94LCBldmVudCk7CiB9CiAKLXN0YXRpYyBpbmxpbmUgdm9pZCB1bmNvcmVfYm94X2luaXQoc3RydWN0IGludGVsX3VuY29yZV9ib3ggKmJveCkKLXsKLQlpZiAoIXRlc3RfYW5kX3NldF9iaXQoVU5DT1JFX0JPWF9GTEFHX0lOSVRJQVRFRCwgJmJveC0+ZmxhZ3MpKSB7Ci0JCWlmIChib3gtPnBtdS0+dHlwZS0+b3BzLT5pbml0X2JveCkKLQkJCWJveC0+cG11LT50eXBlLT5vcHMtPmluaXRfYm94KGJveCk7Ci0JfQotfQotCiBzdGF0aWMgaW5saW5lIGJvb2wgdW5jb3JlX2JveF9pc19mYWtlKHN0cnVjdCBpbnRlbF91bmNvcmVfYm94ICpib3gpCiB7CiAJcmV0dXJuIChib3gtPnBoeXNfaWQgPCAwKTsKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC9mdHJhY2UuYyBiL2FyY2gveDg2L2tlcm5lbC9mdHJhY2UuYwppbmRleCAyMTQyMzc2Li44YjdiMGE1IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvZnRyYWNlLmMKKysrIGIvYXJjaC94ODYva2VybmVsL2Z0cmFjZS5jCkBAIC02NzQsNyArNjc0LDcgQEAKIH0KIHN0YXRpYyBpbmxpbmUgdm9pZCB0cmFtcF9mcmVlKHZvaWQgKnRyYW1wKQogewotCW1vZHVsZV9mcmVlKE5VTEwsIHRyYW1wKTsKKwltb2R1bGVfbWVtZnJlZSh0cmFtcCk7CiB9CiAjZWxzZQogLyogVHJhbXBvbGluZXMgY2FuIG9ubHkgYmUgY3JlYXRlZCBpZiBtb2R1bGVzIGFyZSBzdXBwb3J0ZWQgKi8KZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC9pcnEuYyBiL2FyY2gveDg2L2tlcm5lbC9pcnEuYwppbmRleCA2MzA3YTBmLi43MDVlZjhkIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvaXJxLmMKKysrIGIvYXJjaC94ODYva2VybmVsL2lycS5jCkBAIC0xMjcsNyArMTI3LDcgQEAKIAlzZXFfcHV0cyhwLCAiICBNYWNoaW5lIGNoZWNrIHBvbGxzXG4iKTsKICNlbmRpZgogI2lmIElTX0VOQUJMRUQoQ09ORklHX0hZUEVSVikgfHwgZGVmaW5lZChDT05GSUdfWEVOKQotCXNlcV9wcmludGYocCwgIiUqczogIiwgcHJlYywgIlRIUiIpOworCXNlcV9wcmludGYocCwgIiUqczogIiwgcHJlYywgIkhZUCIpOwogCWZvcl9lYWNoX29ubGluZV9jcHUoaikKIAkJc2VxX3ByaW50ZihwLCAiJTEwdSAiLCBpcnFfc3RhdHMoaiktPmlycV9odl9jYWxsYmFja19jb3VudCk7CiAJc2VxX3B1dHMocCwgIiAgSHlwZXJ2aXNvciBjYWxsYmFjayBpbnRlcnJ1cHRzXG4iKTsKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC90bHMuYyBiL2FyY2gveDg2L2tlcm5lbC90bHMuYwppbmRleCA0ZTk0MmYzLi43ZmM1ZTg0IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvdGxzLmMKKysrIGIvYXJjaC94ODYva2VybmVsL3Rscy5jCkBAIC0yOSw3ICsyOSwyOCBAQAogCiBzdGF0aWMgYm9vbCB0bHNfZGVzY19va2F5KGNvbnN0IHN0cnVjdCB1c2VyX2Rlc2MgKmluZm8pCiB7Ci0JaWYgKExEVF9lbXB0eShpbmZvKSkKKwkvKgorCSAqIEZvciBoaXN0b3JpY2FsIHJlYXNvbnMgKGkuZS4gbm8gb25lIGV2ZXIgZG9jdW1lbnRlZCBob3cgYW55CisJICogb2YgdGhlIHNlZ21lbnRhdGlvbiBBUElzIHdvcmspLCB1c2VyIHByb2dyYW1zIGNhbiBhbmQgZG8KKwkgKiBhc3N1bWUgdGhhdCBhIHN0cnVjdCB1c2VyX2Rlc2MgdGhhdCdzIGFsbCB6ZXJvcyBleGNlcHQgZm9yCisJICogZW50cnlfbnVtYmVyIG1lYW5zICJubyBzZWdtZW50IGF0IGFsbCIuICBUaGlzIG5ldmVyIGFjdHVhbGx5CisJICogd29ya2VkLiAgSW4gZmFjdCwgdXAgdG8gTGludXggMy4xOSwgYSBzdHJ1Y3QgdXNlcl9kZXNjIGxpa2UKKwkgKiB0aGlzIHdvdWxkIGNyZWF0ZSBhIDE2LWJpdCByZWFkLXdyaXRlIHNlZ21lbnQgd2l0aCBiYXNlIGFuZAorCSAqIGxpbWl0IGJvdGggZXF1YWwgdG8gemVyby4KKwkgKgorCSAqIFRoYXQgd2FzIGNsb3NlIGVub3VnaCB0byAibm8gc2VnbWVudCBhdCBhbGwiIHVudGlsIHdlCisJICogaGFyZGVuZWQgdGhpcyBmdW5jdGlvbiB0byBkaXNhbGxvdyAxNi1iaXQgVExTIHNlZ21lbnRzLiAgRml4CisJICogaXQgdXAgYnkgaW50ZXJwcmV0aW5nIHRoZXNlIHplcm9lZCBzZWdtZW50cyB0aGUgd2F5IHRoYXQgdGhleQorCSAqIHdlcmUgYWxtb3N0IGNlcnRhaW5seSBpbnRlbmRlZCB0byBiZSBpbnRlcnByZXRlZC4KKwkgKgorCSAqIFRoZSBjb3JyZWN0IHdheSB0byBhc2sgZm9yICJubyBzZWdtZW50IGF0IGFsbCIgaXMgdG8gc3BlY2lmeQorCSAqIGEgdXNlcl9kZXNjIHRoYXQgc2F0aXNmaWVzIExEVF9lbXB0eS4gIFRvIGtlZXAgZXZlcnl0aGluZworCSAqIHdvcmtpbmcsIHdlIGFjY2VwdCBib3RoLgorCSAqCisJICogTm90ZSB0aGF0IHRoZXJlJ3MgYSBzaW1pbGFyIGtsdWRnZSBpbiBtb2RpZnlfbGR0IC0tIGxvb2sgYXQKKwkgKiB0aGUgZGlzdGluY3Rpb24gYmV0d2VlbiBtb2RlcyAxIGFuZCAweDExLgorCSAqLworCWlmIChMRFRfZW1wdHkoaW5mbykgfHwgTERUX3plcm8oaW5mbykpCiAJCXJldHVybiB0cnVlOwogCiAJLyoKQEAgLTcxLDcgKzkyLDcgQEAKIAljcHUgPSBnZXRfY3B1KCk7CiAKIAl3aGlsZSAobi0tID4gMCkgewotCQlpZiAoTERUX2VtcHR5KGluZm8pKQorCQlpZiAoTERUX2VtcHR5KGluZm8pIHx8IExEVF96ZXJvKGluZm8pKQogCQkJZGVzYy0+YSA9IGRlc2MtPmIgPSAwOwogCQllbHNlCiAJCQlmaWxsX2xkdChkZXNjLCBpbmZvKTsKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC90c2MuYyBiL2FyY2gveDg2L2tlcm5lbC90c2MuYwppbmRleCBiN2U1MGJiLi41MDU0NDk3IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvdHNjLmMKKysrIGIvYXJjaC94ODYva2VybmVsL3RzYy5jCkBAIC02MTcsNyArNjE3LDcgQEAKIAkJCWdvdG8gc3VjY2VzczsKIAkJfQogCX0KLQlwcl9lcnIoIkZhc3QgVFNDIGNhbGlicmF0aW9uIGZhaWxlZFxuIik7CisJcHJfaW5mbygiRmFzdCBUU0MgY2FsaWJyYXRpb24gZmFpbGVkXG4iKTsKIAlyZXR1cm4gMDsKIAogc3VjY2VzczoKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2t2bS9lbXVsYXRlLmMgYi9hcmNoL3g4Ni9rdm0vZW11bGF0ZS5jCmluZGV4IDE2OWIwOWQuLmRlMTJjMWQgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2t2bS9lbXVsYXRlLmMKKysrIGIvYXJjaC94ODYva3ZtL2VtdWxhdGUuYwpAQCAtMjM0OCw3ICsyMzQ4LDcgQEAKIAkgKiBOb3QgcmVjb2duaXplZCBvbiBBTUQgaW4gY29tcGF0IG1vZGUgKGJ1dCBpcyByZWNvZ25pemVkIGluIGxlZ2FjeQogCSAqIG1vZGUpLgogCSAqLwotCWlmICgoY3R4dC0+bW9kZSA9PSBYODZFTVVMX01PREVfUFJPVDMyKSAmJiAoZWZlciAmIEVGRVJfTE1BKQorCWlmICgoY3R4dC0+bW9kZSAhPSBYODZFTVVMX01PREVfUFJPVDY0KSAmJiAoZWZlciAmIEVGRVJfTE1BKQogCSAgICAmJiAhdmVuZG9yX2ludGVsKGN0eHQpKQogCQlyZXR1cm4gZW11bGF0ZV91ZChjdHh0KTsKIApAQCAtMjM1OSwyNSArMjM1OSwxMyBAQAogCXNldHVwX3N5c2NhbGxzX3NlZ21lbnRzKGN0eHQsICZjcywgJnNzKTsKIAogCW9wcy0+Z2V0X21zcihjdHh0LCBNU1JfSUEzMl9TWVNFTlRFUl9DUywgJm1zcl9kYXRhKTsKLQlzd2l0Y2ggKGN0eHQtPm1vZGUpIHsKLQljYXNlIFg4NkVNVUxfTU9ERV9QUk9UMzI6Ci0JCWlmICgobXNyX2RhdGEgJiAweGZmZmMpID09IDB4MCkKLQkJCXJldHVybiBlbXVsYXRlX2dwKGN0eHQsIDApOwotCQlicmVhazsKLQljYXNlIFg4NkVNVUxfTU9ERV9QUk9UNjQ6Ci0JCWlmIChtc3JfZGF0YSA9PSAweDApCi0JCQlyZXR1cm4gZW11bGF0ZV9ncChjdHh0LCAwKTsKLQkJYnJlYWs7Ci0JZGVmYXVsdDoKLQkJYnJlYWs7Ci0JfQorCWlmICgobXNyX2RhdGEgJiAweGZmZmMpID09IDB4MCkKKwkJcmV0dXJuIGVtdWxhdGVfZ3AoY3R4dCwgMCk7CiAKIAljdHh0LT5lZmxhZ3MgJj0gfihFRkxHX1ZNIHwgRUZMR19JRik7Ci0JY3Nfc2VsID0gKHUxNiltc3JfZGF0YTsKLQljc19zZWwgJj0gflNFTEVDVE9SX1JQTF9NQVNLOworCWNzX3NlbCA9ICh1MTYpbXNyX2RhdGEgJiB+U0VMRUNUT1JfUlBMX01BU0s7CiAJc3Nfc2VsID0gY3Nfc2VsICsgODsKLQlzc19zZWwgJj0gflNFTEVDVE9SX1JQTF9NQVNLOwotCWlmIChjdHh0LT5tb2RlID09IFg4NkVNVUxfTU9ERV9QUk9UNjQgfHwgKGVmZXIgJiBFRkVSX0xNQSkpIHsKKwlpZiAoZWZlciAmIEVGRVJfTE1BKSB7CiAJCWNzLmQgPSAwOwogCQljcy5sID0gMTsKIAl9CkBAIC0yMzg2LDEwICsyMzc0LDExIEBACiAJb3BzLT5zZXRfc2VnbWVudChjdHh0LCBzc19zZWwsICZzcywgMCwgVkNQVV9TUkVHX1NTKTsKIAogCW9wcy0+Z2V0X21zcihjdHh0LCBNU1JfSUEzMl9TWVNFTlRFUl9FSVAsICZtc3JfZGF0YSk7Ci0JY3R4dC0+X2VpcCA9IG1zcl9kYXRhOworCWN0eHQtPl9laXAgPSAoZWZlciAmIEVGRVJfTE1BKSA/IG1zcl9kYXRhIDogKHUzMiltc3JfZGF0YTsKIAogCW9wcy0+Z2V0X21zcihjdHh0LCBNU1JfSUEzMl9TWVNFTlRFUl9FU1AsICZtc3JfZGF0YSk7Ci0JKnJlZ193cml0ZShjdHh0LCBWQ1BVX1JFR1NfUlNQKSA9IG1zcl9kYXRhOworCSpyZWdfd3JpdGUoY3R4dCwgVkNQVV9SRUdTX1JTUCkgPSAoZWZlciAmIEVGRVJfTE1BKSA/IG1zcl9kYXRhIDoKKwkJCQkJCQkgICAgICAodTMyKW1zcl9kYXRhOwogCiAJcmV0dXJuIFg4NkVNVUxfQ09OVElOVUU7CiB9CkBAIC0zNzkxLDggKzM3ODAsOCBAQAogfTsKIAogc3RhdGljIGNvbnN0IHN0cnVjdCBvcGNvZGUgZ3JvdXA2W10gPSB7Ci0JREkoUHJvdCwJc2xkdCksCi0JREkoUHJvdCwJc3RyKSwKKwlESShQcm90IHwgRHN0TWVtLAlzbGR0KSwKKwlESShQcm90IHwgRHN0TWVtLAlzdHIpLAogCUlJKFByb3QgfCBQcml2IHwgU3JjTWVtMTYsIGVtX2xsZHQsIGxsZHQpLAogCUlJKFByb3QgfCBQcml2IHwgU3JjTWVtMTYsIGVtX2x0ciwgbHRyKSwKIAlOLCBOLCBOLCBOLApkaWZmIC0tZ2l0IGEvYXJjaC94ODYva3ZtL2xhcGljLmMgYi9hcmNoL3g4Ni9rdm0vbGFwaWMuYwppbmRleCA0ZjBjMGI5Li5kNTJkY2YwIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rdm0vbGFwaWMuYworKysgYi9hcmNoL3g4Ni9rdm0vbGFwaWMuYwpAQCAtMTkyLDYgKzE5Miw5IEBACiAJCXUxNiBjaWQsIGxpZDsKIAkJdTMyIGxkciwgYWlkOwogCisJCWlmICgha3ZtX2FwaWNfcHJlc2VudCh2Y3B1KSkKKwkJCWNvbnRpbnVlOworCiAJCWFpZCA9IGt2bV9hcGljX2lkKGFwaWMpOwogCQlsZHIgPSBrdm1fYXBpY19nZXRfcmVnKGFwaWMsIEFQSUNfTERSKTsKIAkJY2lkID0gYXBpY19jbHVzdGVyX2lkKG5ldywgbGRyKTsKZGlmZiAtLWdpdCBhL2FyY2gveDg2L21tL2ZhdWx0LmMgYi9hcmNoL3g4Ni9tbS9mYXVsdC5jCmluZGV4IDM4ZGNlYzQuLmUzZmYyN2EgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L21tL2ZhdWx0LmMKKysrIGIvYXJjaC94ODYvbW0vZmF1bHQuYwpAQCAtODk4LDYgKzg5OCw4IEBACiAJCWlmIChmYXVsdCAmIChWTV9GQVVMVF9TSUdCVVN8Vk1fRkFVTFRfSFdQT0lTT058CiAJCQkgICAgIFZNX0ZBVUxUX0hXUE9JU09OX0xBUkdFKSkKIAkJCWRvX3NpZ2J1cyhyZWdzLCBlcnJvcl9jb2RlLCBhZGRyZXNzLCBmYXVsdCk7CisJCWVsc2UgaWYgKGZhdWx0ICYgVk1fRkFVTFRfU0lHU0VHVikKKwkJCWJhZF9hcmVhX25vc2VtYXBob3JlKHJlZ3MsIGVycm9yX2NvZGUsIGFkZHJlc3MpOwogCQllbHNlCiAJCQlCVUcoKTsKIAl9CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9tbS9pbml0LmMgYi9hcmNoL3g4Ni9tbS9pbml0LmMKaW5kZXggMDhhN2QzMS4uMDc5YzNiNiAxMDA2NDQKLS0tIGEvYXJjaC94ODYvbW0vaW5pdC5jCisrKyBiL2FyY2gveDg2L21tL2luaXQuYwpAQCAtNDMsNyArNDMsNyBAQAogCVtfUEFHRV9DQUNIRV9NT0RFX1dUXQkJPSBfUEFHRV9QQ0QsCiAJW19QQUdFX0NBQ0hFX01PREVfV1BdCQk9IF9QQUdFX1BDRCwKIH07Ci1FWFBPUlRfU1lNQk9MX0dQTChfX2NhY2hlbW9kZTJwdGVfdGJsKTsKK0VYUE9SVF9TWU1CT0woX19jYWNoZW1vZGUycHRlX3RibCk7CiB1aW50OF90IF9fcHRlMmNhY2hlbW9kZV90YmxbOF0gPSB7CiAJW19fcHRlMmNtX2lkeCgwKV0gPSBfUEFHRV9DQUNIRV9NT0RFX1dCLAogCVtfX3B0ZTJjbV9pZHgoX1BBR0VfUFdUKV0gPSBfUEFHRV9DQUNIRV9NT0RFX1dDLApAQCAtNTQsNyArNTQsNyBAQAogCVtfX3B0ZTJjbV9pZHgoX1BBR0VfUENEIHwgX1BBR0VfUEFUKV0gPSBfUEFHRV9DQUNIRV9NT0RFX1VDX01JTlVTLAogCVtfX3B0ZTJjbV9pZHgoX1BBR0VfUFdUIHwgX1BBR0VfUENEIHwgX1BBR0VfUEFUKV0gPSBfUEFHRV9DQUNIRV9NT0RFX1VDLAogfTsKLUVYUE9SVF9TWU1CT0xfR1BMKF9fcHRlMmNhY2hlbW9kZV90YmwpOworRVhQT1JUX1NZTUJPTChfX3B0ZTJjYWNoZW1vZGVfdGJsKTsKIAogc3RhdGljIHVuc2lnbmVkIGxvbmcgX19pbml0ZGF0YSBwZ3RfYnVmX3N0YXJ0Owogc3RhdGljIHVuc2lnbmVkIGxvbmcgX19pbml0ZGF0YSBwZ3RfYnVmX2VuZDsKZGlmZiAtLWdpdCBhL2FyY2gveDg2L21tL21weC5jIGIvYXJjaC94ODYvbW0vbXB4LmMKaW5kZXggNjdlYmY1Ny4uYzQzOWVjNCAxMDA2NDQKLS0tIGEvYXJjaC94ODYvbW0vbXB4LmMKKysrIGIvYXJjaC94ODYvbW0vbXB4LmMKQEAgLTM0OSw2ICszNDksMTIgQEAKIAkJcmV0dXJuIE1QWF9JTlZBTElEX0JPVU5EU19ESVI7CiAKIAkvKgorCSAqIDMyLWJpdCBiaW5hcmllcyBvbiA2NC1iaXQga2VybmVscyBhcmUgY3VycmVudGx5CisJICogdW5zdXBwb3J0ZWQuCisJICovCisJaWYgKElTX0VOQUJMRUQoQ09ORklHX1g4Nl82NCkgJiYgdGVzdF90aHJlYWRfZmxhZyhUSUZfSUEzMikpCisJCXJldHVybiBNUFhfSU5WQUxJRF9CT1VORFNfRElSOworCS8qCiAJICogVGhlIGJvdW5kcyBkaXJlY3RvcnkgcG9pbnRlciBpcyBzdG9yZWQgaW4gYSByZWdpc3RlcgogCSAqIG9ubHkgYWNjZXNzaWJsZSBpZiB3ZSBmaXJzdCBkbyBhbiB4c2F2ZS4KIAkgKi8KZGlmZiAtLWdpdCBhL2FyY2gveDg2L21tL3BhdC5jIGIvYXJjaC94ODYvbW0vcGF0LmMKaW5kZXggZWRmMjk5Yy4uN2FjNjg2OSAxMDA2NDQKLS0tIGEvYXJjaC94ODYvbW0vcGF0LmMKKysrIGIvYXJjaC94ODYvbW0vcGF0LmMKQEAgLTIzNCw4ICsyMzQsMTMgQEAKIAkgICAgICBQQVQoNCwgV0IpIHwgUEFUKDUsIFdDKSB8IFBBVCg2LCBVQ19NSU5VUykgfCBQQVQoNywgVUMpOwogCiAJLyogQm9vdCBDUFUgY2hlY2sgKi8KLQlpZiAoIWJvb3RfcGF0X3N0YXRlKQorCWlmICghYm9vdF9wYXRfc3RhdGUpIHsKIAkJcmRtc3JsKE1TUl9JQTMyX0NSX1BBVCwgYm9vdF9wYXRfc3RhdGUpOworCQlpZiAoIWJvb3RfcGF0X3N0YXRlKSB7CisJCQlwYXRfZGlzYWJsZSgiUEFUIHJlYWQgcmV0dXJucyBhbHdheXMgemVybywgZGlzYWJsZWQuIik7CisJCQlyZXR1cm47CisJCX0KKwl9CiAKIAl3cm1zcmwoTVNSX0lBMzJfQ1JfUEFULCBwYXQpOwogCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9wY2kvYWNwaS5jIGIvYXJjaC94ODYvcGNpL2FjcGkuYwppbmRleCBjZmQxYjEzLi42YWMyNzM4IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9wY2kvYWNwaS5jCisrKyBiL2FyY2gveDg2L3BjaS9hY3BpLmMKQEAgLTEwLDkgKzEwLDYgQEAKIHN0cnVjdCBwY2lfcm9vdF9pbmZvIHsKIAlzdHJ1Y3QgYWNwaV9kZXZpY2UgKmJyaWRnZTsKIAljaGFyIG5hbWVbMTZdOwotCXVuc2lnbmVkIGludCByZXNfbnVtOwotCXN0cnVjdCByZXNvdXJjZSAqcmVzOwotCXJlc291cmNlX3NpemVfdCAqcmVzX29mZnNldDsKIAlzdHJ1Y3QgcGNpX3N5c2RhdGEgc2Q7CiAjaWZkZWYJQ09ORklHX1BDSV9NTUNPTkZJRwogCWJvb2wgbWNmZ19hZGRlZDsKQEAgLTIxOCwxMzAgKzIxNSw0MSBAQAogfQogI2VuZGlmCiAKLXN0YXRpYyBhY3BpX3N0YXR1cyByZXNvdXJjZV90b19hZGRyKHN0cnVjdCBhY3BpX3Jlc291cmNlICpyZXNvdXJjZSwKLQkJCQkgICAgc3RydWN0IGFjcGlfcmVzb3VyY2VfYWRkcmVzczY0ICphZGRyKQorc3RhdGljIHZvaWQgdmFsaWRhdGVfcmVzb3VyY2VzKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGxpc3RfaGVhZCAqY3JzX3JlcywKKwkJCSAgICAgICB1bnNpZ25lZCBsb25nIHR5cGUpCiB7Ci0JYWNwaV9zdGF0dXMgc3RhdHVzOwotCXN0cnVjdCBhY3BpX3Jlc291cmNlX21lbW9yeTI0ICptZW1vcnkyNDsKLQlzdHJ1Y3QgYWNwaV9yZXNvdXJjZV9tZW1vcnkzMiAqbWVtb3J5MzI7Ci0Jc3RydWN0IGFjcGlfcmVzb3VyY2VfZml4ZWRfbWVtb3J5MzIgKmZpeGVkX21lbW9yeTMyOworCUxJU1RfSEVBRChsaXN0KTsKKwlzdHJ1Y3QgcmVzb3VyY2UgKnJlczEsICpyZXMyLCAqcm9vdCA9IE5VTEw7CisJc3RydWN0IHJlc291cmNlX2VudHJ5ICp0bXAsICplbnRyeSwgKmVudHJ5MjsKIAotCW1lbXNldChhZGRyLCAwLCBzaXplb2YoKmFkZHIpKTsKLQlzd2l0Y2ggKHJlc291cmNlLT50eXBlKSB7Ci0JY2FzZSBBQ1BJX1JFU09VUkNFX1RZUEVfTUVNT1JZMjQ6Ci0JCW1lbW9yeTI0ID0gJnJlc291cmNlLT5kYXRhLm1lbW9yeTI0OwotCQlhZGRyLT5yZXNvdXJjZV90eXBlID0gQUNQSV9NRU1PUllfUkFOR0U7Ci0JCWFkZHItPm1pbmltdW0gPSBtZW1vcnkyNC0+bWluaW11bTsKLQkJYWRkci0+YWRkcmVzc19sZW5ndGggPSBtZW1vcnkyNC0+YWRkcmVzc19sZW5ndGg7Ci0JCWFkZHItPm1heGltdW0gPSBhZGRyLT5taW5pbXVtICsgYWRkci0+YWRkcmVzc19sZW5ndGggLSAxOwotCQlyZXR1cm4gQUVfT0s7Ci0JY2FzZSBBQ1BJX1JFU09VUkNFX1RZUEVfTUVNT1JZMzI6Ci0JCW1lbW9yeTMyID0gJnJlc291cmNlLT5kYXRhLm1lbW9yeTMyOwotCQlhZGRyLT5yZXNvdXJjZV90eXBlID0gQUNQSV9NRU1PUllfUkFOR0U7Ci0JCWFkZHItPm1pbmltdW0gPSBtZW1vcnkzMi0+bWluaW11bTsKLQkJYWRkci0+YWRkcmVzc19sZW5ndGggPSBtZW1vcnkzMi0+YWRkcmVzc19sZW5ndGg7Ci0JCWFkZHItPm1heGltdW0gPSBhZGRyLT5taW5pbXVtICsgYWRkci0+YWRkcmVzc19sZW5ndGggLSAxOwotCQlyZXR1cm4gQUVfT0s7Ci0JY2FzZSBBQ1BJX1JFU09VUkNFX1RZUEVfRklYRURfTUVNT1JZMzI6Ci0JCWZpeGVkX21lbW9yeTMyID0gJnJlc291cmNlLT5kYXRhLmZpeGVkX21lbW9yeTMyOwotCQlhZGRyLT5yZXNvdXJjZV90eXBlID0gQUNQSV9NRU1PUllfUkFOR0U7Ci0JCWFkZHItPm1pbmltdW0gPSBmaXhlZF9tZW1vcnkzMi0+YWRkcmVzczsKLQkJYWRkci0+YWRkcmVzc19sZW5ndGggPSBmaXhlZF9tZW1vcnkzMi0+YWRkcmVzc19sZW5ndGg7Ci0JCWFkZHItPm1heGltdW0gPSBhZGRyLT5taW5pbXVtICsgYWRkci0+YWRkcmVzc19sZW5ndGggLSAxOwotCQlyZXR1cm4gQUVfT0s7Ci0JY2FzZSBBQ1BJX1JFU09VUkNFX1RZUEVfQUREUkVTUzE2OgotCWNhc2UgQUNQSV9SRVNPVVJDRV9UWVBFX0FERFJFU1MzMjoKLQljYXNlIEFDUElfUkVTT1VSQ0VfVFlQRV9BRERSRVNTNjQ6Ci0JCXN0YXR1cyA9IGFjcGlfcmVzb3VyY2VfdG9fYWRkcmVzczY0KHJlc291cmNlLCBhZGRyKTsKLQkJaWYgKEFDUElfU1VDQ0VTUyhzdGF0dXMpICYmCi0JCSAgICAoYWRkci0+cmVzb3VyY2VfdHlwZSA9PSBBQ1BJX01FTU9SWV9SQU5HRSB8fAotCQkgICAgYWRkci0+cmVzb3VyY2VfdHlwZSA9PSBBQ1BJX0lPX1JBTkdFKSAmJgotCQkgICAgYWRkci0+YWRkcmVzc19sZW5ndGggPiAwKSB7Ci0JCQlyZXR1cm4gQUVfT0s7Ci0JCX0KLQkJYnJlYWs7Ci0JfQotCXJldHVybiBBRV9FUlJPUjsKLX0KKwlCVUdfT04oKHR5cGUgJiAoSU9SRVNPVVJDRV9NRU0gfCBJT1JFU09VUkNFX0lPKSkgPT0gMCk7CisJcm9vdCA9ICh0eXBlICYgSU9SRVNPVVJDRV9NRU0pID8gJmlvbWVtX3Jlc291cmNlIDogJmlvcG9ydF9yZXNvdXJjZTsKIAotc3RhdGljIGFjcGlfc3RhdHVzIGNvdW50X3Jlc291cmNlKHN0cnVjdCBhY3BpX3Jlc291cmNlICphY3BpX3Jlcywgdm9pZCAqZGF0YSkKLXsKLQlzdHJ1Y3QgcGNpX3Jvb3RfaW5mbyAqaW5mbyA9IGRhdGE7Ci0Jc3RydWN0IGFjcGlfcmVzb3VyY2VfYWRkcmVzczY0IGFkZHI7Ci0JYWNwaV9zdGF0dXMgc3RhdHVzOworCWxpc3Rfc3BsaWNlX2luaXQoY3JzX3JlcywgJmxpc3QpOworCXJlc291cmNlX2xpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShlbnRyeSwgdG1wLCAmbGlzdCkgeworCQlib29sIGZyZWUgPSBmYWxzZTsKKwkJcmVzb3VyY2Vfc2l6ZV90IGVuZDsKIAotCXN0YXR1cyA9IHJlc291cmNlX3RvX2FkZHIoYWNwaV9yZXMsICZhZGRyKTsKLQlpZiAoQUNQSV9TVUNDRVNTKHN0YXR1cykpCi0JCWluZm8tPnJlc19udW0rKzsKLQlyZXR1cm4gQUVfT0s7Ci19Ci0KLXN0YXRpYyBhY3BpX3N0YXR1cyBzZXR1cF9yZXNvdXJjZShzdHJ1Y3QgYWNwaV9yZXNvdXJjZSAqYWNwaV9yZXMsIHZvaWQgKmRhdGEpCi17Ci0Jc3RydWN0IHBjaV9yb290X2luZm8gKmluZm8gPSBkYXRhOwotCXN0cnVjdCByZXNvdXJjZSAqcmVzOwotCXN0cnVjdCBhY3BpX3Jlc291cmNlX2FkZHJlc3M2NCBhZGRyOwotCWFjcGlfc3RhdHVzIHN0YXR1czsKLQl1bnNpZ25lZCBsb25nIGZsYWdzOwotCXU2NCBzdGFydCwgb3JpZ19lbmQsIGVuZDsKLQotCXN0YXR1cyA9IHJlc291cmNlX3RvX2FkZHIoYWNwaV9yZXMsICZhZGRyKTsKLQlpZiAoIUFDUElfU1VDQ0VTUyhzdGF0dXMpKQotCQlyZXR1cm4gQUVfT0s7Ci0KLQlpZiAoYWRkci5yZXNvdXJjZV90eXBlID09IEFDUElfTUVNT1JZX1JBTkdFKSB7Ci0JCWZsYWdzID0gSU9SRVNPVVJDRV9NRU07Ci0JCWlmIChhZGRyLmluZm8ubWVtLmNhY2hpbmcgPT0gQUNQSV9QUkVGRVRDSEFCTEVfTUVNT1JZKQotCQkJZmxhZ3MgfD0gSU9SRVNPVVJDRV9QUkVGRVRDSDsKLQl9IGVsc2UgaWYgKGFkZHIucmVzb3VyY2VfdHlwZSA9PSBBQ1BJX0lPX1JBTkdFKSB7Ci0JCWZsYWdzID0gSU9SRVNPVVJDRV9JTzsKLQl9IGVsc2UKLQkJcmV0dXJuIEFFX09LOwotCi0Jc3RhcnQgPSBhZGRyLm1pbmltdW0gKyBhZGRyLnRyYW5zbGF0aW9uX29mZnNldDsKLQlvcmlnX2VuZCA9IGVuZCA9IGFkZHIubWF4aW11bSArIGFkZHIudHJhbnNsYXRpb25fb2Zmc2V0OwotCi0JLyogRXhjbHVkZSBub24tYWRkcmVzc2FibGUgcmFuZ2Ugb3Igbm9uLWFkZHJlc3NhYmxlIHBvcnRpb24gb2YgcmFuZ2UgKi8KLQllbmQgPSBtaW4oZW5kLCAodTY0KWlvbWVtX3Jlc291cmNlLmVuZCk7Ci0JaWYgKGVuZCA8PSBzdGFydCkgewotCQlkZXZfaW5mbygmaW5mby0+YnJpZGdlLT5kZXYsCi0JCQkiaG9zdCBicmlkZ2Ugd2luZG93IFslI2xseC0lI2xseF0gIgotCQkJIihpZ25vcmVkLCBub3QgQ1BVIGFkZHJlc3NhYmxlKVxuIiwgc3RhcnQsIG9yaWdfZW5kKTsKLQkJcmV0dXJuIEFFX09LOwotCX0gZWxzZSBpZiAob3JpZ19lbmQgIT0gZW5kKSB7Ci0JCWRldl9pbmZvKCZpbmZvLT5icmlkZ2UtPmRldiwKLQkJCSJob3N0IGJyaWRnZSB3aW5kb3cgWyUjbGx4LSUjbGx4XSAiCi0JCQkiKFslI2xseC0lI2xseF0gaWdub3JlZCwgbm90IENQVSBhZGRyZXNzYWJsZSlcbiIsIAotCQkJc3RhcnQsIG9yaWdfZW5kLCBlbmQgKyAxLCBvcmlnX2VuZCk7Ci0JfQotCi0JcmVzID0gJmluZm8tPnJlc1tpbmZvLT5yZXNfbnVtXTsKLQlyZXMtPm5hbWUgPSBpbmZvLT5uYW1lOwotCXJlcy0+ZmxhZ3MgPSBmbGFnczsKLQlyZXMtPnN0YXJ0ID0gc3RhcnQ7Ci0JcmVzLT5lbmQgPSBlbmQ7Ci0JaW5mby0+cmVzX29mZnNldFtpbmZvLT5yZXNfbnVtXSA9IGFkZHIudHJhbnNsYXRpb25fb2Zmc2V0OwotCWluZm8tPnJlc19udW0rKzsKLQotCWlmICghcGNpX3VzZV9jcnMpCi0JCWRldl9wcmludGsoS0VSTl9ERUJVRywgJmluZm8tPmJyaWRnZS0+ZGV2LAotCQkJICAgImhvc3QgYnJpZGdlIHdpbmRvdyAlcFIgKGlnbm9yZWQpXG4iLCByZXMpOwotCi0JcmV0dXJuIEFFX09LOwotfQotCi1zdGF0aWMgdm9pZCBjb2FsZXNjZV93aW5kb3dzKHN0cnVjdCBwY2lfcm9vdF9pbmZvICppbmZvLCB1bnNpZ25lZCBsb25nIHR5cGUpCi17Ci0JaW50IGksIGo7Ci0Jc3RydWN0IHJlc291cmNlICpyZXMxLCAqcmVzMjsKLQotCWZvciAoaSA9IDA7IGkgPCBpbmZvLT5yZXNfbnVtOyBpKyspIHsKLQkJcmVzMSA9ICZpbmZvLT5yZXNbaV07CisJCXJlczEgPSBlbnRyeS0+cmVzOwogCQlpZiAoIShyZXMxLT5mbGFncyAmIHR5cGUpKQotCQkJY29udGludWU7CisJCQlnb3RvIG5leHQ7CiAKLQkJZm9yIChqID0gaSArIDE7IGogPCBpbmZvLT5yZXNfbnVtOyBqKyspIHsKLQkJCXJlczIgPSAmaW5mby0+cmVzW2pdOworCQkvKiBFeGNsdWRlIG5vbi1hZGRyZXNzYWJsZSByYW5nZSBvciBub24tYWRkcmVzc2FibGUgcG9ydGlvbiAqLworCQllbmQgPSBtaW4ocmVzMS0+ZW5kLCByb290LT5lbmQpOworCQlpZiAoZW5kIDw9IHJlczEtPnN0YXJ0KSB7CisJCQlkZXZfaW5mbyhkZXYsICJob3N0IGJyaWRnZSB3aW5kb3cgJXBSIChpZ25vcmVkLCBub3QgQ1BVIGFkZHJlc3NhYmxlKVxuIiwKKwkJCQkgcmVzMSk7CisJCQlmcmVlID0gdHJ1ZTsKKwkJCWdvdG8gbmV4dDsKKwkJfSBlbHNlIGlmIChyZXMxLT5lbmQgIT0gZW5kKSB7CisJCQlkZXZfaW5mbyhkZXYsICJob3N0IGJyaWRnZSB3aW5kb3cgJXBSIChbJSNsbHgtJSNsbHhdIGlnbm9yZWQsIG5vdCBDUFUgYWRkcmVzc2FibGUpXG4iLAorCQkJCSByZXMxLCAodW5zaWduZWQgbG9uZyBsb25nKWVuZCArIDEsCisJCQkJICh1bnNpZ25lZCBsb25nIGxvbmcpcmVzMS0+ZW5kKTsKKwkJCXJlczEtPmVuZCA9IGVuZDsKKwkJfQorCisJCXJlc291cmNlX2xpc3RfZm9yX2VhY2hfZW50cnkoZW50cnkyLCBjcnNfcmVzKSB7CisJCQlyZXMyID0gZW50cnkyLT5yZXM7CiAJCQlpZiAoIShyZXMyLT5mbGFncyAmIHR5cGUpKQogCQkJCWNvbnRpbnVlOwogCkBAIC0zNTMsMTE4ICsyNjEsOTIgQEAKIAkJCWlmIChyZXNvdXJjZV9vdmVybGFwcyhyZXMxLCByZXMyKSkgewogCQkJCXJlczItPnN0YXJ0ID0gbWluKHJlczEtPnN0YXJ0LCByZXMyLT5zdGFydCk7CiAJCQkJcmVzMi0+ZW5kID0gbWF4KHJlczEtPmVuZCwgcmVzMi0+ZW5kKTsKLQkJCQlkZXZfaW5mbygmaW5mby0+YnJpZGdlLT5kZXYsCi0JCQkJCSAiaG9zdCBicmlkZ2Ugd2luZG93IGV4cGFuZGVkIHRvICVwUjsgJXBSIGlnbm9yZWRcbiIsCisJCQkJZGV2X2luZm8oZGV2LCAiaG9zdCBicmlkZ2Ugd2luZG93IGV4cGFuZGVkIHRvICVwUjsgJXBSIGlnbm9yZWRcbiIsCiAJCQkJCSByZXMyLCByZXMxKTsKLQkJCQlyZXMxLT5mbGFncyA9IDA7CisJCQkJZnJlZSA9IHRydWU7CisJCQkJZ290byBuZXh0OwogCQkJfQogCQl9CisKK25leHQ6CisJCXJlc291cmNlX2xpc3RfZGVsKGVudHJ5KTsKKwkJaWYgKGZyZWUpCisJCQlyZXNvdXJjZV9saXN0X2ZyZWVfZW50cnkoZW50cnkpOworCQllbHNlCisJCQlyZXNvdXJjZV9saXN0X2FkZF90YWlsKGVudHJ5LCBjcnNfcmVzKTsKIAl9CiB9CiAKIHN0YXRpYyB2b2lkIGFkZF9yZXNvdXJjZXMoc3RydWN0IHBjaV9yb290X2luZm8gKmluZm8sCi0JCQkgIHN0cnVjdCBsaXN0X2hlYWQgKnJlc291cmNlcykKKwkJCSAgc3RydWN0IGxpc3RfaGVhZCAqcmVzb3VyY2VzLAorCQkJICBzdHJ1Y3QgbGlzdF9oZWFkICpjcnNfcmVzKQogewotCWludCBpOwotCXN0cnVjdCByZXNvdXJjZSAqcmVzLCAqcm9vdCwgKmNvbmZsaWN0OworCXN0cnVjdCByZXNvdXJjZV9lbnRyeSAqZW50cnksICp0bXA7CisJc3RydWN0IHJlc291cmNlICpyZXMsICpjb25mbGljdCwgKnJvb3QgPSBOVUxMOwogCi0JY29hbGVzY2Vfd2luZG93cyhpbmZvLCBJT1JFU09VUkNFX01FTSk7Ci0JY29hbGVzY2Vfd2luZG93cyhpbmZvLCBJT1JFU09VUkNFX0lPKTsKKwl2YWxpZGF0ZV9yZXNvdXJjZXMoJmluZm8tPmJyaWRnZS0+ZGV2LCBjcnNfcmVzLCBJT1JFU09VUkNFX01FTSk7CisJdmFsaWRhdGVfcmVzb3VyY2VzKCZpbmZvLT5icmlkZ2UtPmRldiwgY3JzX3JlcywgSU9SRVNPVVJDRV9JTyk7CiAKLQlmb3IgKGkgPSAwOyBpIDwgaW5mby0+cmVzX251bTsgaSsrKSB7Ci0JCXJlcyA9ICZpbmZvLT5yZXNbaV07Ci0KKwlyZXNvdXJjZV9saXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoZW50cnksIHRtcCwgY3JzX3JlcykgeworCQlyZXMgPSBlbnRyeS0+cmVzOwogCQlpZiAocmVzLT5mbGFncyAmIElPUkVTT1VSQ0VfTUVNKQogCQkJcm9vdCA9ICZpb21lbV9yZXNvdXJjZTsKIAkJZWxzZSBpZiAocmVzLT5mbGFncyAmIElPUkVTT1VSQ0VfSU8pCiAJCQlyb290ID0gJmlvcG9ydF9yZXNvdXJjZTsKIAkJZWxzZQotCQkJY29udGludWU7CisJCQlCVUdfT04ocmVzKTsKIAogCQljb25mbGljdCA9IGluc2VydF9yZXNvdXJjZV9jb25mbGljdChyb290LCByZXMpOwotCQlpZiAoY29uZmxpY3QpCisJCWlmIChjb25mbGljdCkgewogCQkJZGV2X2luZm8oJmluZm8tPmJyaWRnZS0+ZGV2LAogCQkJCSAiaWdub3JpbmcgaG9zdCBicmlkZ2Ugd2luZG93ICVwUiAoY29uZmxpY3RzIHdpdGggJXMgJXBSKVxuIiwKIAkJCQkgcmVzLCBjb25mbGljdC0+bmFtZSwgY29uZmxpY3QpOwotCQllbHNlCi0JCQlwY2lfYWRkX3Jlc291cmNlX29mZnNldChyZXNvdXJjZXMsIHJlcywKLQkJCQkJaW5mby0+cmVzX29mZnNldFtpXSk7Ci0JfQotfQotCi1zdGF0aWMgdm9pZCBmcmVlX3BjaV9yb290X2luZm9fcmVzKHN0cnVjdCBwY2lfcm9vdF9pbmZvICppbmZvKQotewotCWtmcmVlKGluZm8tPnJlcyk7Ci0JaW5mby0+cmVzID0gTlVMTDsKLQlrZnJlZShpbmZvLT5yZXNfb2Zmc2V0KTsKLQlpbmZvLT5yZXNfb2Zmc2V0ID0gTlVMTDsKLQlpbmZvLT5yZXNfbnVtID0gMDsKLX0KLQotc3RhdGljIHZvaWQgX19yZWxlYXNlX3BjaV9yb290X2luZm8oc3RydWN0IHBjaV9yb290X2luZm8gKmluZm8pCi17Ci0JaW50IGk7Ci0Jc3RydWN0IHJlc291cmNlICpyZXM7Ci0KLQlmb3IgKGkgPSAwOyBpIDwgaW5mby0+cmVzX251bTsgaSsrKSB7Ci0JCXJlcyA9ICZpbmZvLT5yZXNbaV07Ci0KLQkJaWYgKCFyZXMtPnBhcmVudCkKLQkJCWNvbnRpbnVlOwotCi0JCWlmICghKHJlcy0+ZmxhZ3MgJiAoSU9SRVNPVVJDRV9NRU0gfCBJT1JFU09VUkNFX0lPKSkpCi0JCQljb250aW51ZTsKLQotCQlyZWxlYXNlX3Jlc291cmNlKHJlcyk7CisJCQlyZXNvdXJjZV9saXN0X2Rlc3Ryb3lfZW50cnkoZW50cnkpOworCQl9CiAJfQogCi0JZnJlZV9wY2lfcm9vdF9pbmZvX3JlcyhpbmZvKTsKLQotCXRlYXJkb3duX21jZmdfbWFwKGluZm8pOwotCi0Ja2ZyZWUoaW5mbyk7CisJbGlzdF9zcGxpY2VfdGFpbChjcnNfcmVzLCByZXNvdXJjZXMpOwogfQogCiBzdGF0aWMgdm9pZCByZWxlYXNlX3BjaV9yb290X2luZm8oc3RydWN0IHBjaV9ob3N0X2JyaWRnZSAqYnJpZGdlKQogeworCXN0cnVjdCByZXNvdXJjZSAqcmVzOworCXN0cnVjdCByZXNvdXJjZV9lbnRyeSAqZW50cnk7CiAJc3RydWN0IHBjaV9yb290X2luZm8gKmluZm8gPSBicmlkZ2UtPnJlbGVhc2VfZGF0YTsKIAotCV9fcmVsZWFzZV9wY2lfcm9vdF9pbmZvKGluZm8pOworCXJlc291cmNlX2xpc3RfZm9yX2VhY2hfZW50cnkoZW50cnksICZicmlkZ2UtPndpbmRvd3MpIHsKKwkJcmVzID0gZW50cnktPnJlczsKKwkJaWYgKHJlcy0+cGFyZW50ICYmCisJCSAgICAocmVzLT5mbGFncyAmIChJT1JFU09VUkNFX01FTSB8IElPUkVTT1VSQ0VfSU8pKSkKKwkJCXJlbGVhc2VfcmVzb3VyY2UocmVzKTsKKwl9CisKKwl0ZWFyZG93bl9tY2ZnX21hcChpbmZvKTsKKwlrZnJlZShpbmZvKTsKIH0KIAogc3RhdGljIHZvaWQgcHJvYmVfcGNpX3Jvb3RfaW5mbyhzdHJ1Y3QgcGNpX3Jvb3RfaW5mbyAqaW5mbywKIAkJCQlzdHJ1Y3QgYWNwaV9kZXZpY2UgKmRldmljZSwKLQkJCQlpbnQgYnVzbnVtLCBpbnQgZG9tYWluKQorCQkJCWludCBidXNudW0sIGludCBkb21haW4sCisJCQkJc3RydWN0IGxpc3RfaGVhZCAqbGlzdCkKIHsKLQlzaXplX3Qgc2l6ZTsKKwlpbnQgcmV0OworCXN0cnVjdCByZXNvdXJjZV9lbnRyeSAqZW50cnk7CiAKIAlzcHJpbnRmKGluZm8tPm5hbWUsICJQQ0kgQnVzICUwNHg6JTAyeCIsIGRvbWFpbiwgYnVzbnVtKTsKIAlpbmZvLT5icmlkZ2UgPSBkZXZpY2U7Ci0KLQlpbmZvLT5yZXNfbnVtID0gMDsKLQlhY3BpX3dhbGtfcmVzb3VyY2VzKGRldmljZS0+aGFuZGxlLCBNRVRIT0RfTkFNRV9fQ1JTLCBjb3VudF9yZXNvdXJjZSwKLQkJCQlpbmZvKTsKLQlpZiAoIWluZm8tPnJlc19udW0pCi0JCXJldHVybjsKLQotCXNpemUgPSBzaXplb2YoKmluZm8tPnJlcykgKiBpbmZvLT5yZXNfbnVtOwotCWluZm8tPnJlcyA9IGt6YWxsb2Nfbm9kZShzaXplLCBHRlBfS0VSTkVMLCBpbmZvLT5zZC5ub2RlKTsKLQlpZiAoIWluZm8tPnJlcykgewotCQlpbmZvLT5yZXNfbnVtID0gMDsKLQkJcmV0dXJuOwotCX0KLQotCXNpemUgPSBzaXplb2YoKmluZm8tPnJlc19vZmZzZXQpICogaW5mby0+cmVzX251bTsKLQlpbmZvLT5yZXNfbnVtID0gMDsKLQlpbmZvLT5yZXNfb2Zmc2V0ID0ga3phbGxvY19ub2RlKHNpemUsIEdGUF9LRVJORUwsIGluZm8tPnNkLm5vZGUpOwotCWlmICghaW5mby0+cmVzX29mZnNldCkgewotCQlrZnJlZShpbmZvLT5yZXMpOwotCQlpbmZvLT5yZXMgPSBOVUxMOwotCQlyZXR1cm47Ci0JfQotCi0JYWNwaV93YWxrX3Jlc291cmNlcyhkZXZpY2UtPmhhbmRsZSwgTUVUSE9EX05BTUVfX0NSUywgc2V0dXBfcmVzb3VyY2UsCi0JCQkJaW5mbyk7CisJcmV0ID0gYWNwaV9kZXZfZ2V0X3Jlc291cmNlcyhkZXZpY2UsIGxpc3QsCisJCQkJICAgICBhY3BpX2Rldl9maWx0ZXJfcmVzb3VyY2VfdHlwZV9jYiwKKwkJCQkgICAgICh2b2lkICopKElPUkVTT1VSQ0VfSU8gfCBJT1JFU09VUkNFX01FTSkpOworCWlmIChyZXQgPCAwKQorCQlkZXZfd2FybigmZGV2aWNlLT5kZXYsCisJCQkgImZhaWxlZCB0byBwYXJzZSBfQ1JTIG1ldGhvZCwgZXJyb3IgY29kZSAlZFxuIiwgcmV0KTsKKwllbHNlIGlmIChyZXQgPT0gMCkKKwkJZGV2X2RiZygmZGV2aWNlLT5kZXYsCisJCQkibm8gSU8gYW5kIG1lbW9yeSByZXNvdXJjZXMgcHJlc2VudCBpbiBfQ1JTXG4iKTsKKwllbHNlCisJCXJlc291cmNlX2xpc3RfZm9yX2VhY2hfZW50cnkoZW50cnksIGxpc3QpCisJCQllbnRyeS0+cmVzLT5uYW1lID0gaW5mby0+bmFtZTsKIH0KIAogc3RydWN0IHBjaV9idXMgKnBjaV9hY3BpX3NjYW5fcm9vdChzdHJ1Y3QgYWNwaV9wY2lfcm9vdCAqcm9vdCkKQEAgLTQ3Myw2ICszNTUsOCBAQAogCXN0cnVjdCBwY2lfcm9vdF9pbmZvICppbmZvOwogCWludCBkb21haW4gPSByb290LT5zZWdtZW50OwogCWludCBidXNudW0gPSByb290LT5zZWNvbmRhcnkuc3RhcnQ7CisJc3RydWN0IHJlc291cmNlX2VudHJ5ICpyZXNfZW50cnk7CisJTElTVF9IRUFEKGNyc19yZXMpOwogCUxJU1RfSEVBRChyZXNvdXJjZXMpOwogCXN0cnVjdCBwY2lfYnVzICpidXM7CiAJc3RydWN0IHBjaV9zeXNkYXRhICpzZDsKQEAgLTUyMCwxOCArNDA0LDIyIEBACiAJCW1lbWNweShidXMtPnN5c2RhdGEsIHNkLCBzaXplb2YoKnNkKSk7CiAJCWtmcmVlKGluZm8pOwogCX0gZWxzZSB7Ci0JCXByb2JlX3BjaV9yb290X2luZm8oaW5mbywgZGV2aWNlLCBidXNudW0sIGRvbWFpbik7Ci0KIAkJLyogaW5zZXJ0IGJ1c24gcmVzIGF0IGZpcnN0ICovCiAJCXBjaV9hZGRfcmVzb3VyY2UoJnJlc291cmNlcywgICZyb290LT5zZWNvbmRhcnkpOworCiAJCS8qCiAJCSAqIF9DUlMgd2l0aCBubyBhcGVydHVyZXMgaXMgbm9ybWFsLCBzbyBvbmx5IGZhbGwgYmFjayB0bwogCQkgKiBkZWZhdWx0cyBvciBuYXRpdmUgYnJpZGdlIGluZm8gaWYgd2UncmUgaWdub3JpbmcgX0NSUy4KIAkJICovCi0JCWlmIChwY2lfdXNlX2NycykKLQkJCWFkZF9yZXNvdXJjZXMoaW5mbywgJnJlc291cmNlcyk7Ci0JCWVsc2UgewotCQkJZnJlZV9wY2lfcm9vdF9pbmZvX3JlcyhpbmZvKTsKKwkJcHJvYmVfcGNpX3Jvb3RfaW5mbyhpbmZvLCBkZXZpY2UsIGJ1c251bSwgZG9tYWluLCAmY3JzX3Jlcyk7CisJCWlmIChwY2lfdXNlX2NycykgeworCQkJYWRkX3Jlc291cmNlcyhpbmZvLCAmcmVzb3VyY2VzLCAmY3JzX3Jlcyk7CisJCX0gZWxzZSB7CisJCQlyZXNvdXJjZV9saXN0X2Zvcl9lYWNoX2VudHJ5KHJlc19lbnRyeSwgJmNyc19yZXMpCisJCQkJZGV2X3ByaW50ayhLRVJOX0RFQlVHLCAmZGV2aWNlLT5kZXYsCisJCQkJCSAgICJob3N0IGJyaWRnZSB3aW5kb3cgJXBSIChpZ25vcmVkKVxuIiwKKwkJCQkJICAgcmVzX2VudHJ5LT5yZXMpOworCQkJcmVzb3VyY2VfbGlzdF9mcmVlKCZjcnNfcmVzKTsKIAkJCXg4Nl9wY2lfcm9vdF9idXNfcmVzb3VyY2VzKGJ1c251bSwgJnJlc291cmNlcyk7CiAJCX0KIApAQCAtNTQ2LDggKzQzNCw5IEBACiAJCQkJdG9fcGNpX2hvc3RfYnJpZGdlKGJ1cy0+YnJpZGdlKSwKIAkJCQlyZWxlYXNlX3BjaV9yb290X2luZm8sIGluZm8pOwogCQl9IGVsc2UgewotCQkJcGNpX2ZyZWVfcmVzb3VyY2VfbGlzdCgmcmVzb3VyY2VzKTsKLQkJCV9fcmVsZWFzZV9wY2lfcm9vdF9pbmZvKGluZm8pOworCQkJcmVzb3VyY2VfbGlzdF9mcmVlKCZyZXNvdXJjZXMpOworCQkJdGVhcmRvd25fbWNmZ19tYXAoaW5mbyk7CisJCQlrZnJlZShpbmZvKTsKIAkJfQogCX0KIApkaWZmIC0tZ2l0IGEvYXJjaC94ODYvcGNpL2J1c19udW1hLmMgYi9hcmNoL3g4Ni9wY2kvYnVzX251bWEuYwppbmRleCBmM2EyY2ZjLi43YmNmMDZhIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9wY2kvYnVzX251bWEuYworKysgYi9hcmNoL3g4Ni9wY2kvYnVzX251bWEuYwpAQCAtMzEsNyArMzEsNyBAQAogewogCXN0cnVjdCBwY2lfcm9vdF9pbmZvICppbmZvID0geDg2X2ZpbmRfcGNpX3Jvb3RfaW5mbyhidXMpOwogCXN0cnVjdCBwY2lfcm9vdF9yZXMgKnJvb3RfcmVzOwotCXN0cnVjdCBwY2lfaG9zdF9icmlkZ2Vfd2luZG93ICp3aW5kb3c7CisJc3RydWN0IHJlc291cmNlX2VudHJ5ICp3aW5kb3c7CiAJYm9vbCBmb3VuZCA9IGZhbHNlOwogCiAJaWYgKCFpbmZvKQpAQCAtNDEsNyArNDEsNyBAQAogCSAgICAgICBidXMpOwogCiAJLyogYWxyZWFkeSBhZGRlZCBieSBhY3BpID8gKi8KLQlsaXN0X2Zvcl9lYWNoX2VudHJ5KHdpbmRvdywgcmVzb3VyY2VzLCBsaXN0KQorCXJlc291cmNlX2xpc3RfZm9yX2VhY2hfZW50cnkod2luZG93LCByZXNvdXJjZXMpCiAJCWlmICh3aW5kb3ctPnJlcy0+ZmxhZ3MgJiBJT1JFU09VUkNFX0JVUykgewogCQkJZm91bmQgPSB0cnVlOwogCQkJYnJlYWs7CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9wY2kvY29tbW9uLmMgYi9hcmNoL3g4Ni9wY2kvY29tbW9uLmMKaW5kZXggN2IyMGJjYy4uM2QyNjEyYiAxMDA2NDQKLS0tIGEvYXJjaC94ODYvcGNpL2NvbW1vbi5jCisrKyBiL2FyY2gveDg2L3BjaS9jb21tb24uYwpAQCAtNDQ4LDYgKzQ0OCwyMiBAQAogCQkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJmdFNlcnZlciIpLAogCQl9LAogCX0sCisgICAgICAgIHsKKyAgICAgICAgICAgICAgICAuY2FsbGJhY2sgPSBzZXRfc2Nhbl9hbGwsCisgICAgICAgICAgICAgICAgLmlkZW50ID0gIlN0cmF0dXMvTkVDIGZ0U2VydmVyIiwKKyAgICAgICAgICAgICAgICAubWF0Y2hlcyA9IHsKKyAgICAgICAgICAgICAgICAgICAgICAgIERNSV9NQVRDSChETUlfU1lTX1ZFTkRPUiwgIk5FQyIpLAorICAgICAgICAgICAgICAgICAgICAgICAgRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJFeHByZXNzNTgwMC9SMzIiKSwKKyAgICAgICAgICAgICAgICB9LAorICAgICAgICB9LAorICAgICAgICB7CisgICAgICAgICAgICAgICAgLmNhbGxiYWNrID0gc2V0X3NjYW5fYWxsLAorICAgICAgICAgICAgICAgIC5pZGVudCA9ICJTdHJhdHVzL05FQyBmdFNlcnZlciIsCisgICAgICAgICAgICAgICAgLm1hdGNoZXMgPSB7CisgICAgICAgICAgICAgICAgICAgICAgICBETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJORUMiKSwKKyAgICAgICAgICAgICAgICAgICAgICAgIERNSV9NQVRDSChETUlfUFJPRFVDVF9OQU1FLCAiRXhwcmVzczU4MDAvUjMxIiksCisgICAgICAgICAgICAgICAgfSwKKyAgICAgICAgfSwKIAl7fQogfTsKIApAQCAtNDk3LDYgKzUxMywzMSBAQAogCX0KIH0KIAorLyoKKyAqIFNvbWUgZGV2aWNlIGRyaXZlcnMgYXNzdW1lIGRldi0+aXJxIHdvbid0IGNoYW5nZSBhZnRlciBjYWxsaW5nCisgKiBwY2lfZGlzYWJsZV9kZXZpY2UoKS4gU28gZGVsYXkgcmVsZWFzaW5nIG9mIElSUSByZXNvdXJjZSB0byBkcml2ZXIKKyAqIHVuYmluZGluZyB0aW1lLiBPdGhlcndpc2UgaXQgd2lsbCBicmVhayBQTSBzdWJzeXN0ZW0gYW5kIGRyaXZlcnMKKyAqIGxpa2UgeGVuLXBjaWJhY2sgZXRjLgorICovCitzdGF0aWMgaW50IHBjaV9pcnFfbm90aWZpZXIoc3RydWN0IG5vdGlmaWVyX2Jsb2NrICpuYiwgdW5zaWduZWQgbG9uZyBhY3Rpb24sCisJCQkgICAgdm9pZCAqZGF0YSkKK3sKKwlzdHJ1Y3QgcGNpX2RldiAqZGV2ID0gdG9fcGNpX2RldihkYXRhKTsKKworCWlmIChhY3Rpb24gIT0gQlVTX05PVElGWV9VTkJPVU5EX0RSSVZFUikKKwkJcmV0dXJuIE5PVElGWV9ET05FOworCisJaWYgKHBjaWJpb3NfZGlzYWJsZV9pcnEpCisJCXBjaWJpb3NfZGlzYWJsZV9pcnEoZGV2KTsKKworCXJldHVybiBOT1RJRllfT0s7Cit9CisKK3N0YXRpYyBzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sgcGNpX2lycV9uYiA9IHsKKwkubm90aWZpZXJfY2FsbCA9IHBjaV9pcnFfbm90aWZpZXIsCisJLnByaW9yaXR5ID0gSU5UX01JTiwKK307CisKIGludCBfX2luaXQgcGNpYmlvc19pbml0KHZvaWQpCiB7CiAJaWYgKCFyYXdfcGNpX29wcykgewpAQCAtNTA5LDYgKzU1MCw5IEBACiAKIAlpZiAocGNpX2JmX3NvcnQgPj0gcGNpX2ZvcmNlX2JmKQogCQlwY2lfc29ydF9icmVhZHRoZmlyc3QoKTsKKworCWJ1c19yZWdpc3Rlcl9ub3RpZmllcigmcGNpX2J1c190eXBlLCAmcGNpX2lycV9uYik7CisKIAlyZXR1cm4gMDsKIH0KIApAQCAtNjY3LDEyICs3MTEsNiBAQAogCXJldHVybiAwOwogfQogCi12b2lkIHBjaWJpb3NfZGlzYWJsZV9kZXZpY2UgKHN0cnVjdCBwY2lfZGV2ICpkZXYpCi17Ci0JaWYgKCFwY2lfZGV2X21zaV9lbmFibGVkKGRldikgJiYgcGNpYmlvc19kaXNhYmxlX2lycSkKLQkJcGNpYmlvc19kaXNhYmxlX2lycShkZXYpOwotfQotCiBpbnQgcGNpX2V4dF9jZmdfYXZhaWwodm9pZCkKIHsKIAlpZiAocmF3X3BjaV9leHRfb3BzKQpkaWZmIC0tZ2l0IGEvYXJjaC94ODYvcGNpL2kzODYuYyBiL2FyY2gveDg2L3BjaS9pMzg2LmMKaW5kZXggOWIxOGVmMy4uMzQ5YzBkMyAxMDA2NDQKLS0tIGEvYXJjaC94ODYvcGNpL2kzODYuYworKysgYi9hcmNoL3g4Ni9wY2kvaTM4Ni5jCkBAIC0yMTYsNyArMjE2LDcgQEAKIAkJCWNvbnRpbnVlOwogCQlpZiAoci0+cGFyZW50KQkvKiBBbHJlYWR5IGFsbG9jYXRlZCAqLwogCQkJY29udGludWU7Ci0JCWlmICghci0+c3RhcnQgfHwgcGNpX2NsYWltX3Jlc291cmNlKGRldiwgaWR4KSA8IDApIHsKKwkJaWYgKCFyLT5zdGFydCB8fCBwY2lfY2xhaW1fYnJpZGdlX3Jlc291cmNlKGRldiwgaWR4KSA8IDApIHsKIAkJCS8qCiAJCQkgKiBTb21ldGhpbmcgaXMgd3Jvbmcgd2l0aCB0aGUgcmVnaW9uLgogCQkJICogSW52YWxpZGF0ZSB0aGUgcmVzb3VyY2UgdG8gcHJldmVudApkaWZmIC0tZ2l0IGEvYXJjaC94ODYvcGNpL2ludGVsX21pZF9wY2kuYyBiL2FyY2gveDg2L3BjaS9pbnRlbF9taWRfcGNpLmMKaW5kZXggNDRiOTI3MS4uOTVjMjQ3MSAxMDA2NDQKLS0tIGEvYXJjaC94ODYvcGNpL2ludGVsX21pZF9wY2kuYworKysgYi9hcmNoL3g4Ni9wY2kvaW50ZWxfbWlkX3BjaS5jCkBAIC0yMzQsMTAgKzIzNCwxMCBAQAogCiBzdGF0aWMgdm9pZCBpbnRlbF9taWRfcGNpX2lycV9kaXNhYmxlKHN0cnVjdCBwY2lfZGV2ICpkZXYpCiB7Ci0JaWYgKCFtcF9zaG91bGRfa2VlcF9pcnEoJmRldi0+ZGV2KSAmJiBkZXYtPmlycV9tYW5hZ2VkICYmCi0JICAgIGRldi0+aXJxID4gMCkgeworCWlmIChkZXYtPmlycV9tYW5hZ2VkICYmIGRldi0+aXJxID4gMCkgewogCQltcF91bm1hcF9pcnEoZGV2LT5pcnEpOwogCQlkZXYtPmlycV9tYW5hZ2VkID0gMDsKKwkJZGV2LT5pcnEgPSAwOwogCX0KIH0KIApkaWZmIC0tZ2l0IGEvYXJjaC94ODYvcGNpL2lycS5jIGIvYXJjaC94ODYvcGNpL2lycS5jCmluZGV4IDVkYzZjYTUuLmU3MWIzZGIgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L3BjaS9pcnEuYworKysgYi9hcmNoL3g4Ni9wY2kvaXJxLmMKQEAgLTEyNTYsMjIgKzEyNTYsOSBAQAogCXJldHVybiAwOwogfQogCi1ib29sIG1wX3Nob3VsZF9rZWVwX2lycShzdHJ1Y3QgZGV2aWNlICpkZXYpCi17Ci0JaWYgKGRldi0+cG93ZXIuaXNfcHJlcGFyZWQpCi0JCXJldHVybiB0cnVlOwotI2lmZGVmIENPTkZJR19QTQotCWlmIChkZXYtPnBvd2VyLnJ1bnRpbWVfc3RhdHVzID09IFJQTV9TVVNQRU5ESU5HKQotCQlyZXR1cm4gdHJ1ZTsKLSNlbmRpZgotCi0JcmV0dXJuIGZhbHNlOwotfQotCiBzdGF0aWMgdm9pZCBwaXJxX2Rpc2FibGVfaXJxKHN0cnVjdCBwY2lfZGV2ICpkZXYpCiB7Ci0JaWYgKGlvX2FwaWNfYXNzaWduX3BjaV9pcnFzICYmICFtcF9zaG91bGRfa2VlcF9pcnEoJmRldi0+ZGV2KSAmJgotCSAgICBkZXYtPmlycV9tYW5hZ2VkICYmIGRldi0+aXJxKSB7CisJaWYgKGlvX2FwaWNfYXNzaWduX3BjaV9pcnFzICYmIGRldi0+aXJxX21hbmFnZWQgJiYgZGV2LT5pcnEpIHsKIAkJbXBfdW5tYXBfaXJxKGRldi0+aXJxKTsKIAkJZGV2LT5pcnEgPSAwOwogCQlkZXYtPmlycV9tYW5hZ2VkID0gMDsKZGlmZiAtLWdpdCBhL2FyY2gveDg2L3BjaS9tbWNvbmZpZy1zaGFyZWQuYyBiL2FyY2gveDg2L3BjaS9tbWNvbmZpZy1zaGFyZWQuYwppbmRleCAzMjYxOThhLi41YThkY2VhIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9wY2kvbW1jb25maWctc2hhcmVkLmMKKysrIGIvYXJjaC94ODYvcGNpL21tY29uZmlnLXNoYXJlZC5jCkBAIC0zOTcsMTIgKzM5NywxMiBAQAogCiAJc3RhdHVzID0gYWNwaV9yZXNvdXJjZV90b19hZGRyZXNzNjQocmVzLCAmYWRkcmVzcyk7CiAJaWYgKEFDUElfRkFJTFVSRShzdGF0dXMpIHx8Ci0JICAgKGFkZHJlc3MuYWRkcmVzc19sZW5ndGggPD0gMCkgfHwKKwkgICAoYWRkcmVzcy5hZGRyZXNzLmFkZHJlc3NfbGVuZ3RoIDw9IDApIHx8CiAJICAgKGFkZHJlc3MucmVzb3VyY2VfdHlwZSAhPSBBQ1BJX01FTU9SWV9SQU5HRSkpCiAJCXJldHVybiBBRV9PSzsKIAotCWlmICgobWNmZ19yZXMtPnN0YXJ0ID49IGFkZHJlc3MubWluaW11bSkgJiYKLQkgICAgKG1jZmdfcmVzLT5lbmQgPCAoYWRkcmVzcy5taW5pbXVtICsgYWRkcmVzcy5hZGRyZXNzX2xlbmd0aCkpKSB7CisJaWYgKChtY2ZnX3Jlcy0+c3RhcnQgPj0gYWRkcmVzcy5hZGRyZXNzLm1pbmltdW0pICYmCisJICAgIChtY2ZnX3Jlcy0+ZW5kIDwgKGFkZHJlc3MuYWRkcmVzcy5taW5pbXVtICsgYWRkcmVzcy5hZGRyZXNzLmFkZHJlc3NfbGVuZ3RoKSkpIHsKIAkJbWNmZ19yZXMtPmZsYWdzID0gMTsKIAkJcmV0dXJuIEFFX0NUUkxfVEVSTUlOQVRFOwogCX0KZGlmZiAtLWdpdCBhL2FyY2gveDg2L3BjaS94ZW4uYyBiL2FyY2gveDg2L3BjaS94ZW4uYwppbmRleCBjNDg5ZWYyLi45MDk4ZDg4IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9wY2kveGVuLmMKKysrIGIvYXJjaC94ODYvcGNpL3hlbi5jCkBAIC00NTgsNiArNDU4LDcgQEAKIAkgKiBqdXN0IGhvdyBHU0lzIGdldCByZWdpc3RlcmVkLgogCSAqLwogCV9fYWNwaV9yZWdpc3Rlcl9nc2kgPSBhY3BpX3JlZ2lzdGVyX2dzaV94ZW5faHZtOworCV9fYWNwaV91bnJlZ2lzdGVyX2dzaSA9IE5VTEw7CiAjZW5kaWYKIAogI2lmZGVmIENPTkZJR19QQ0lfTVNJCkBAIC00NzEsNTIgKzQ3Miw2IEBACiB9CiAKICNpZmRlZiBDT05GSUdfWEVOX0RPTTAKLXN0YXRpYyBfX2luaXQgdm9pZCB4ZW5fc2V0dXBfYWNwaV9zY2kodm9pZCkKLXsKLQlpbnQgcmM7Ci0JaW50IHRyaWdnZXIsIHBvbGFyaXR5OwotCWludCBnc2kgPSBhY3BpX3NjaV9vdmVycmlkZV9nc2k7Ci0JaW50IGlycSA9IC0xOwotCWludCBnc2lfb3ZlcnJpZGUgPSAtMTsKLQotCWlmICghZ3NpKQotCQlyZXR1cm47Ci0KLQlyYyA9IGFjcGlfZ2V0X292ZXJyaWRlX2lycShnc2ksICZ0cmlnZ2VyLCAmcG9sYXJpdHkpOwotCWlmIChyYykgewotCQlwcmludGsoS0VSTl9XQVJOSU5HICJ4ZW46IGFjcGlfZ2V0X292ZXJyaWRlX2lycSBmYWlsZWQgZm9yIGFjcGkiCi0JCQkJIiBzY2ksIHJjPSVkXG4iLCByYyk7Ci0JCXJldHVybjsKLQl9Ci0JdHJpZ2dlciA9IHRyaWdnZXIgPyBBQ1BJX0xFVkVMX1NFTlNJVElWRSA6IEFDUElfRURHRV9TRU5TSVRJVkU7Ci0JcG9sYXJpdHkgPSBwb2xhcml0eSA/IEFDUElfQUNUSVZFX0xPVyA6IEFDUElfQUNUSVZFX0hJR0g7Ci0KLQlwcmludGsoS0VSTl9JTkZPICJ4ZW46IHNjaSBvdmVycmlkZTogZ2xvYmFsX2lycT0lZCB0cmlnZ2VyPSVkICIKLQkJCSJwb2xhcml0eT0lZFxuIiwgZ3NpLCB0cmlnZ2VyLCBwb2xhcml0eSk7Ci0KLQkvKiBCZWZvcmUgd2UgYmluZCB0aGUgR1NJIHRvIGEgTGludXggSVJRLCBjaGVjayB3aGV0aGVyCi0JICogd2UgbmVlZCB0byBvdmVycmlkZSBpdCB3aXRoIGJ1c19pcnEgKElSUSkgdmFsdWUuIFVzdWFsbHkgZm9yCi0JICogSVJRcyBiZWxvdyBJUlFfTEVHQUNZX0lSUSB0aGlzIGhvbGRzIElSUSA9PSBHU0ksIGFzIHNvOgotCSAqICBBQ1BJOiBJTlRfU1JDX09WUiAoYnVzIDAgYnVzX2lycSA5IGdsb2JhbF9pcnEgOSBsb3cgbGV2ZWwpCi0JICogYnV0IHRoZXJlIGFyZSBvZGRiYWxscyB3aGVyZSB0aGUgSVJRICE9IEdTSToKLQkgKiAgQUNQSTogSU5UX1NSQ19PVlIgKGJ1cyAwIGJ1c19pcnEgOSBnbG9iYWxfaXJxIDIwIGxvdyBsZXZlbCkKLQkgKiB3aGljaCBlbmRzIHVwIGJlaW5nOiBnc2lfdG9faXJxWzldID09IDIwCi0JICogKHdoaWNoIGlzIHdoYXQgYWNwaV9nc2lfdG9faXJxIGVuZHMgdXAgY2FsbGluZyB3aGVuIHN0YXJ0aW5nIHRoZQotCSAqIHRoZSBBQ1BJIGludGVycHJldGVyIGFuZCBrZWVscyBvdmVyIHNpbmNlIElSUSA5IGhhcyBub3QgYmVlbgotCSAqIHNldHVwIGFzIHdlIGhhZCBzZXR1cCBJUlEgMjAgZm9yIGl0KS4KLQkgKi8KLQlpZiAoYWNwaV9nc2lfdG9faXJxKGdzaSwgJmlycSkgPT0gMCkgewotCQkvKiBVc2UgdGhlIHByb3ZpZGVkIHZhbHVlIGlmIGl0J3MgdmFsaWQuICovCi0JCWlmIChpcnEgPj0gMCkKLQkJCWdzaV9vdmVycmlkZSA9IGlycTsKLQl9Ci0KLQlnc2kgPSB4ZW5fcmVnaXN0ZXJfZ3NpKGdzaSwgZ3NpX292ZXJyaWRlLCB0cmlnZ2VyLCBwb2xhcml0eSk7Ci0JcHJpbnRrKEtFUk5fSU5GTyAieGVuOiBhY3BpIHNjaSAlZFxuIiwgZ3NpKTsKLQotCXJldHVybjsKLX0KLQogaW50IF9faW5pdCBwY2lfeGVuX2luaXRpYWxfZG9tYWluKHZvaWQpCiB7CiAJaW50IGlycTsKQEAgLTUyNyw4ICs0ODIsOCBAQAogCXg4Nl9tc2kucmVzdG9yZV9tc2lfaXJxcyA9IHhlbl9pbml0ZG9tX3Jlc3RvcmVfbXNpX2lycXM7CiAJcGNpX21zaV9pZ25vcmVfbWFzayA9IDE7CiAjZW5kaWYKLQl4ZW5fc2V0dXBfYWNwaV9zY2koKTsKIAlfX2FjcGlfcmVnaXN0ZXJfZ3NpID0gYWNwaV9yZWdpc3Rlcl9nc2lfeGVuOworCV9fYWNwaV91bnJlZ2lzdGVyX2dzaSA9IE5VTEw7CiAJLyogUHJlLWFsbG9jYXRlIGxlZ2FjeSBpcnFzICovCiAJZm9yIChpcnEgPSAwOyBpcnEgPCBucl9sZWdhY3lfaXJxcygpOyBpcnErKykgewogCQlpbnQgdHJpZ2dlciwgcG9sYXJpdHk7CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni90b29scy9jYWxjX3J1bl9zaXplLnBsIGIvYXJjaC94ODYvdG9vbHMvY2FsY19ydW5fc2l6ZS5wbApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMjMyMTBiYS4uMDAwMDAwMAotLS0gYS9hcmNoL3g4Ni90b29scy9jYWxjX3J1bl9zaXplLnBsCisrKyAvZGV2L251bGwKQEAgLTEsMzkgKzAsMCBAQAotIyEvdXNyL2Jpbi9wZXJsCi0jCi0jIENhbGN1bGF0ZSB0aGUgYW1vdW50IG9mIHNwYWNlIG5lZWRlZCB0byBydW4gdGhlIGtlcm5lbCwgaW5jbHVkaW5nIHJvb20gZm9yCi0jIHRoZSAuYnNzIGFuZCAuYnJrIHNlY3Rpb25zLgotIwotIyBVc2FnZToKLSMgb2JqZHVtcCAtaCBhLm91dCB8IHBlcmwgY2FsY19ydW5fc2l6ZS5wbAotdXNlIHN0cmljdDsKLQotbXkgJG1lbV9zaXplID0gMDsKLW15ICRmaWxlX29mZnNldCA9IDA7Ci0KLW15ICRzZWN0aW9ucz0iICpbMC05XSsgXC4oPzpic3N8YnJrKSArIjsKLXdoaWxlICg8PikgewotCWlmICgvXiRzZWN0aW9ucyhbMC05YS1mXSspICsoPzpbMC05YS1mXSsgKyl7Mn0oWzAtOWEtZl0rKS8pIHsKLQkJbXkgJHNpemUgPSBoZXgoJDEpOwotCQlteSAkb2Zmc2V0ID0gaGV4KCQyKTsKLQkJJG1lbV9zaXplICs9ICRzaXplOwotCQlpZiAoJGZpbGVfb2Zmc2V0ID09IDApIHsKLQkJCSRmaWxlX29mZnNldCA9ICRvZmZzZXQ7Ci0JCX0gZWxzaWYgKCRmaWxlX29mZnNldCAhPSAkb2Zmc2V0KSB7Ci0JCQkjIEJGRCBsaW5rZXIgc2hvd3MgdGhlIHNhbWUgZmlsZSBvZmZzZXQgaW4gRUxGLgotCQkJIyBHb2xkIGxpbmtlciBzaG93cyB0aGVtIGFzIGNvbnNlY3V0aXZlLgotCQkJbmV4dCBpZiAoJGZpbGVfb2Zmc2V0ICsgJG1lbV9zaXplID09ICRvZmZzZXQgKyAkc2l6ZSk7Ci0KLQkJCXByaW50ZiBTVERFUlIgImZpbGVfb2Zmc2V0OiAweCVseFxuIiwgJGZpbGVfb2Zmc2V0OwotCQkJcHJpbnRmIFNUREVSUiAibWVtX3NpemU6IDB4JWx4XG4iLCAkbWVtX3NpemU7Ci0JCQlwcmludGYgU1RERVJSICJvZmZzZXQ6IDB4JWx4XG4iLCAkb2Zmc2V0OwotCQkJcHJpbnRmIFNUREVSUiAic2l6ZTogMHglbHhcbiIsICRzaXplOwotCi0JCQlkaWUgIi5ic3MgYW5kIC5icmsgYXJlIG5vbi1jb250aWd1b3VzXG4iOwotCQl9Ci0JfQotfQotCi1pZiAoJGZpbGVfb2Zmc2V0ID09IDApIHsKLQlkaWUgIk5ldmVyIGZvdW5kIC5ic3Mgb3IgLmJyayBmaWxlIG9mZnNldFxuIjsKLX0KLXByaW50ZigiJWRcbiIsICRtZW1fc2l6ZSArICRmaWxlX29mZnNldCk7CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni90b29scy9jYWxjX3J1bl9zaXplLnNoIGIvYXJjaC94ODYvdG9vbHMvY2FsY19ydW5fc2l6ZS5zaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xYTRjMTdiCi0tLSAvZGV2L251bGwKKysrIGIvYXJjaC94ODYvdG9vbHMvY2FsY19ydW5fc2l6ZS5zaApAQCAtMCwwICsxLDQyIEBACisjIS9iaW4vc2gKKyMKKyMgQ2FsY3VsYXRlIHRoZSBhbW91bnQgb2Ygc3BhY2UgbmVlZGVkIHRvIHJ1biB0aGUga2VybmVsLCBpbmNsdWRpbmcgcm9vbSBmb3IKKyMgdGhlIC5ic3MgYW5kIC5icmsgc2VjdGlvbnMuCisjCisjIFVzYWdlOgorIyBvYmpkdW1wIC1oIGEub3V0IHwgc2ggY2FsY19ydW5fc2l6ZS5zaAorCitOVU09J1woWzAtOWEtZkEtRl0qWyBcdF0qXCknCitPVVQ9JChzZWQgLW4gJ3MvXlsgXHQwLTldKi5iW3NyXVtza11bIFx0XSonIiROVU0kTlVNJE5VTSROVU0iJy4qL1wxXDQvcCcpCitpZiBbIC16ICIkT1VUIiBdIDsgdGhlbgorCWVjaG8gIk5ldmVyIGZvdW5kIC5ic3Mgb3IgLmJyayBmaWxlIG9mZnNldCIgPiYyCisJZXhpdCAxCitmaQorCitPVVQ9JChlY2hvICR7T1VUIyB9KQorc2l6ZUE9JChwcmludGYgIiVkIiAweCR7T1VUJSUgKn0pCitPVVQ9JHtPVVQjKiB9CitvZmZzZXRBPSQocHJpbnRmICIlZCIgMHgke09VVCUlICp9KQorT1VUPSR7T1VUIyogfQorc2l6ZUI9JChwcmludGYgIiVkIiAweCR7T1VUJSUgKn0pCitPVVQ9JHtPVVQjKiB9CitvZmZzZXRCPSQocHJpbnRmICIlZCIgMHgke09VVCUlICp9KQorCitydW5fc2l6ZT0kKCggJG9mZnNldEEgKyAkc2l6ZUEgKyAkc2l6ZUIgKSkKKworIyBCRkQgbGlua2VyIHNob3dzIHRoZSBzYW1lIGZpbGUgb2Zmc2V0IGluIEVMRi4KK2lmIFsgIiRvZmZzZXRBIiAtbmUgIiRvZmZzZXRCIiBdIDsgdGhlbgorCSMgR29sZCBsaW5rZXIgc2hvd3MgdGhlbSBhcyBjb25zZWN1dGl2ZS4KKwllbmRCPSQoKCAkb2Zmc2V0QiArICRzaXplQiApKQorCWlmIFsgIiRlbmRCIiAhPSAiJHJ1bl9zaXplIiBdIDsgdGhlbgorCQlwcmludGYgInNpemVBOiAweCV4XG4iICRzaXplQSA+JjIKKwkJcHJpbnRmICJvZmZzZXRBOiAweCV4XG4iICRvZmZzZXRBID4mMgorCQlwcmludGYgInNpemVCOiAweCV4XG4iICRzaXplQiA+JjIKKwkJcHJpbnRmICJvZmZzZXRCOiAweCV4XG4iICRvZmZzZXRCID4mMgorCQllY2hvICIuYnNzIGFuZCAuYnJrIGFyZSBub24tY29udGlndW91cyIgPiYyCisJCWV4aXQgMQorCWZpCitmaQorCitwcmludGYgIiVkXG4iICRydW5fc2l6ZQorZXhpdCAwCmRpZmYgLS1naXQgYS9hcmNoL3h0ZW5zYS9tbS9mYXVsdC5jIGIvYXJjaC94dGVuc2EvbW0vZmF1bHQuYwppbmRleCBiNTdjNGY5Li45ZTM1NzFhIDEwMDY0NAotLS0gYS9hcmNoL3h0ZW5zYS9tbS9mYXVsdC5jCisrKyBiL2FyY2gveHRlbnNhL21tL2ZhdWx0LmMKQEAgLTExNyw2ICsxMTcsOCBAQAogCWlmICh1bmxpa2VseShmYXVsdCAmIFZNX0ZBVUxUX0VSUk9SKSkgewogCQlpZiAoZmF1bHQgJiBWTV9GQVVMVF9PT00pCiAJCQlnb3RvIG91dF9vZl9tZW1vcnk7CisJCWVsc2UgaWYgKGZhdWx0ICYgVk1fRkFVTFRfU0lHU0VHVikKKwkJCWdvdG8gYmFkX2FyZWE7CiAJCWVsc2UgaWYgKGZhdWx0ICYgVk1fRkFVTFRfU0lHQlVTKQogCQkJZ290byBkb19zaWdidXM7CiAJCUJVRygpOwpkaWZmIC0tZ2l0IGEvYmxvY2svYmxrLW1xLmMgYi9ibG9jay9ibGstbXEuYwppbmRleCAyZjk1NzQ3Li4yMzkwYzU1IDEwMDY0NAotLS0gYS9ibG9jay9ibGstbXEuYworKysgYi9ibG9jay9ibGstbXEuYwpAQCAtMTY0MSwxMCArMTY0MSw4IEBACiAJc3RydWN0IGJsa19tcV9od19jdHggKmhjdHg7CiAJdW5zaWduZWQgaW50IGk7CiAKLQlxdWV1ZV9mb3JfZWFjaF9od19jdHgocSwgaGN0eCwgaSkgeworCXF1ZXVlX2Zvcl9lYWNoX2h3X2N0eChxLCBoY3R4LCBpKQogCQlmcmVlX2NwdW1hc2tfdmFyKGhjdHgtPmNwdW1hc2spOwotCQlrZnJlZShoY3R4KTsKLQl9CiB9CiAKIHN0YXRpYyBpbnQgYmxrX21xX2luaXRfaGN0eChzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSwKQEAgLTE4NjksNiArMTg2NywyNyBAQAogCW11dGV4X3VubG9jaygmc2V0LT50YWdfbGlzdF9sb2NrKTsKIH0KIAorLyoKKyAqIEl0IGlzIHRoZSBhY3R1YWwgcmVsZWFzZSBoYW5kbGVyIGZvciBtcSwgYnV0IHdlIGRvIGl0IGZyb20KKyAqIHJlcXVlc3QgcXVldWUncyByZWxlYXNlIGhhbmRsZXIgZm9yIGF2b2lkaW5nIHVzZS1hZnRlci1mcmVlCisgKiBhbmQgaGVhZGFjaGUgYmVjYXVzZSBxLT5tcV9rb2JqIHNob3VsZG4ndCBoYXZlIGJlZW4gaW50cm9kdWNlZCwKKyAqIGJ1dCB3ZSBjYW4ndCBncm91cCBjdHgva2N0eCBrb2JqIHdpdGhvdXQgaXQuCisgKi8KK3ZvaWQgYmxrX21xX3JlbGVhc2Uoc3RydWN0IHJlcXVlc3RfcXVldWUgKnEpCit7CisJc3RydWN0IGJsa19tcV9od19jdHggKmhjdHg7CisJdW5zaWduZWQgaW50IGk7CisKKwkvKiBoY3R4IGtvYmogc3RheXMgaW4gaGN0eCAqLworCXF1ZXVlX2Zvcl9lYWNoX2h3X2N0eChxLCBoY3R4LCBpKQorCQlrZnJlZShoY3R4KTsKKworCWtmcmVlKHEtPnF1ZXVlX2h3X2N0eCk7CisKKwkvKiBjdHgga29iaiBzdGF5cyBpbiBxdWV1ZV9jdHggKi8KKwlmcmVlX3BlcmNwdShxLT5xdWV1ZV9jdHgpOworfQorCiBzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqYmxrX21xX2luaXRfcXVldWUoc3RydWN0IGJsa19tcV90YWdfc2V0ICpzZXQpCiB7CiAJc3RydWN0IGJsa19tcV9od19jdHggKipoY3R4czsKQEAgLTIwMDIsMTIgKzIwMjEsOCBAQAogCiAJcGVyY3B1X3JlZl9leGl0KCZxLT5tcV91c2FnZV9jb3VudGVyKTsKIAotCWZyZWVfcGVyY3B1KHEtPnF1ZXVlX2N0eCk7Ci0Ja2ZyZWUocS0+cXVldWVfaHdfY3R4KTsKIAlrZnJlZShxLT5tcV9tYXApOwogCi0JcS0+cXVldWVfY3R4ID0gTlVMTDsKLQlxLT5xdWV1ZV9od19jdHggPSBOVUxMOwogCXEtPm1xX21hcCA9IE5VTEw7CiAKIAltdXRleF9sb2NrKCZhbGxfcV9tdXRleCk7CmRpZmYgLS1naXQgYS9ibG9jay9ibGstbXEuaCBiL2Jsb2NrL2Jsay1tcS5oCmluZGV4IDRmNGY5NDMuLjZhNDhjNGMgMTAwNjQ0Ci0tLSBhL2Jsb2NrL2Jsay1tcS5oCisrKyBiL2Jsb2NrL2Jsay1tcS5oCkBAIC02Miw2ICs2Miw4IEBACiAKIGV4dGVybiB2b2lkIGJsa19tcV9ycV90aW1lZF9vdXQoc3RydWN0IHJlcXVlc3QgKnJlcSwgYm9vbCByZXNlcnZlZCk7CiAKK3ZvaWQgYmxrX21xX3JlbGVhc2Uoc3RydWN0IHJlcXVlc3RfcXVldWUgKnEpOworCiAvKgogICogQmFzaWMgaW1wbGVtZW50YXRpb24gb2Ygc3BhcnNlciBiaXRtYXAsIGFsbG93aW5nIHRoZSB1c2VyIHRvIHNwcmVhZAogICogdGhlIGJpdHMgb3ZlciBtb3JlIGNhY2hlbGluZXMuCmRpZmYgLS1naXQgYS9ibG9jay9ibGstc3lzZnMuYyBiL2Jsb2NrL2Jsay1zeXNmcy5jCmluZGV4IDkzNWVhMmEuLmZhYWYzNmEgMTAwNjQ0Ci0tLSBhL2Jsb2NrL2Jsay1zeXNmcy5jCisrKyBiL2Jsb2NrL2Jsay1zeXNmcy5jCkBAIC01MTcsNiArNTE3LDggQEAKIAogCWlmICghcS0+bXFfb3BzKQogCQlibGtfZnJlZV9mbHVzaF9xdWV1ZShxLT5mcSk7CisJZWxzZQorCQlibGtfbXFfcmVsZWFzZShxKTsKIAogCWJsa190cmFjZV9zaHV0ZG93bihxKTsKIApkaWZmIC0tZ2l0IGEvY3J5cHRvL2Flc19nZW5lcmljLmMgYi9jcnlwdG8vYWVzX2dlbmVyaWMuYwppbmRleCA5YjNjNTRjLi4zZGQxMDExIDEwMDY0NAotLS0gYS9jcnlwdG8vYWVzX2dlbmVyaWMuYworKysgYi9jcnlwdG8vYWVzX2dlbmVyaWMuYwpAQCAtMTQ3NSwzICsxNDc1LDQgQEAKIE1PRFVMRV9ERVNDUklQVElPTigiUmlqbmRhZWwgKEFFUykgQ2lwaGVyIEFsZ29yaXRobSIpOwogTU9EVUxFX0xJQ0VOU0UoIkR1YWwgQlNEL0dQTCIpOwogTU9EVUxFX0FMSUFTX0NSWVBUTygiYWVzIik7CitNT0RVTEVfQUxJQVNfQ1JZUFRPKCJhZXMtZ2VuZXJpYyIpOwpkaWZmIC0tZ2l0IGEvY3J5cHRvL2Fuc2lfY3BybmcuYyBiL2NyeXB0by9hbnNpX2Nwcm5nLmMKaW5kZXggYjQ0ODVhMS4uNmY1YmViYyAxMDA2NDQKLS0tIGEvY3J5cHRvL2Fuc2lfY3BybmcuYworKysgYi9jcnlwdG8vYW5zaV9jcHJuZy5jCkBAIC00NzcsMyArNDc3LDQgQEAKIG1vZHVsZV9pbml0KHBybmdfbW9kX2luaXQpOwogbW9kdWxlX2V4aXQocHJuZ19tb2RfZmluaSk7CiBNT0RVTEVfQUxJQVNfQ1JZUFRPKCJzdGRybmciKTsKK01PRFVMRV9BTElBU19DUllQVE8oImFuc2lfY3BybmciKTsKZGlmZiAtLWdpdCBhL2NyeXB0by9ibG93ZmlzaF9nZW5lcmljLmMgYi9jcnlwdG8vYmxvd2Zpc2hfZ2VuZXJpYy5jCmluZGV4IDdiZDcxZjAuLjg3YjM5MmEgMTAwNjQ0Ci0tLSBhL2NyeXB0by9ibG93ZmlzaF9nZW5lcmljLmMKKysrIGIvY3J5cHRvL2Jsb3dmaXNoX2dlbmVyaWMuYwpAQCAtMTM5LDMgKzEzOSw0IEBACiBNT0RVTEVfTElDRU5TRSgiR1BMIik7CiBNT0RVTEVfREVTQ1JJUFRJT04oIkJsb3dmaXNoIENpcGhlciBBbGdvcml0aG0iKTsKIE1PRFVMRV9BTElBU19DUllQVE8oImJsb3dmaXNoIik7CitNT0RVTEVfQUxJQVNfQ1JZUFRPKCJibG93ZmlzaC1nZW5lcmljIik7CmRpZmYgLS1naXQgYS9jcnlwdG8vY2FtZWxsaWFfZ2VuZXJpYy5jIGIvY3J5cHRvL2NhbWVsbGlhX2dlbmVyaWMuYwppbmRleCAxYjc0YzVhLi5hMDIyODZiIDEwMDY0NAotLS0gYS9jcnlwdG8vY2FtZWxsaWFfZ2VuZXJpYy5jCisrKyBiL2NyeXB0by9jYW1lbGxpYV9nZW5lcmljLmMKQEAgLTEwOTksMyArMTA5OSw0IEBACiBNT0RVTEVfREVTQ1JJUFRJT04oIkNhbWVsbGlhIENpcGhlciBBbGdvcml0aG0iKTsKIE1PRFVMRV9MSUNFTlNFKCJHUEwiKTsKIE1PRFVMRV9BTElBU19DUllQVE8oImNhbWVsbGlhIik7CitNT0RVTEVfQUxJQVNfQ1JZUFRPKCJjYW1lbGxpYS1nZW5lcmljIik7CmRpZmYgLS1naXQgYS9jcnlwdG8vY2FzdDVfZ2VuZXJpYy5jIGIvY3J5cHRvL2Nhc3Q1X2dlbmVyaWMuYwppbmRleCA4NGM4NmRiLi5kZjVjNzI2IDEwMDY0NAotLS0gYS9jcnlwdG8vY2FzdDVfZ2VuZXJpYy5jCisrKyBiL2NyeXB0by9jYXN0NV9nZW5lcmljLmMKQEAgLTU1MCwzICs1NTAsNCBAQAogTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOwogTU9EVUxFX0RFU0NSSVBUSU9OKCJDYXN0NSBDaXBoZXIgQWxnb3JpdGhtIik7CiBNT0RVTEVfQUxJQVNfQ1JZUFRPKCJjYXN0NSIpOworTU9EVUxFX0FMSUFTX0NSWVBUTygiY2FzdDUtZ2VuZXJpYyIpOwpkaWZmIC0tZ2l0IGEvY3J5cHRvL2Nhc3Q2X2dlbmVyaWMuYyBiL2NyeXB0by9jYXN0Nl9nZW5lcmljLmMKaW5kZXggZjQwOGYwYi4uMDU4YzhkNyAxMDA2NDQKLS0tIGEvY3J5cHRvL2Nhc3Q2X2dlbmVyaWMuYworKysgYi9jcnlwdG8vY2FzdDZfZ2VuZXJpYy5jCkBAIC0yOTIsMyArMjkyLDQgQEAKIE1PRFVMRV9MSUNFTlNFKCJHUEwiKTsKIE1PRFVMRV9ERVNDUklQVElPTigiQ2FzdDYgQ2lwaGVyIEFsZ29yaXRobSIpOwogTU9EVUxFX0FMSUFTX0NSWVBUTygiY2FzdDYiKTsKK01PRFVMRV9BTElBU19DUllQVE8oImNhc3Q2LWdlbmVyaWMiKTsKZGlmZiAtLWdpdCBhL2NyeXB0by9jcmMzMmNfZ2VuZXJpYy5jIGIvY3J5cHRvL2NyYzMyY19nZW5lcmljLmMKaW5kZXggMmEwNjIwMi4uMDZmMWI2MCAxMDA2NDQKLS0tIGEvY3J5cHRvL2NyYzMyY19nZW5lcmljLmMKKysrIGIvY3J5cHRvL2NyYzMyY19nZW5lcmljLmMKQEAgLTE3MSw0ICsxNzEsNSBAQAogTU9EVUxFX0RFU0NSSVBUSU9OKCJDUkMzMmMgKENhc3RhZ25vbGkpIGNhbGN1bGF0aW9ucyB3cmFwcGVyIGZvciBsaWIvY3JjMzJjIik7CiBNT0RVTEVfTElDRU5TRSgiR1BMIik7CiBNT0RVTEVfQUxJQVNfQ1JZUFRPKCJjcmMzMmMiKTsKK01PRFVMRV9BTElBU19DUllQVE8oImNyYzMyYy1nZW5lcmljIik7CiBNT0RVTEVfU09GVERFUCgicHJlOiBjcmMzMmMiKTsKZGlmZiAtLWdpdCBhL2NyeXB0by9jcmN0MTBkaWZfZ2VuZXJpYy5jIGIvY3J5cHRvL2NyY3QxMGRpZl9nZW5lcmljLmMKaW5kZXggMDhiYjRmNS4uYzEyMjk2MTQgMTAwNjQ0Ci0tLSBhL2NyeXB0by9jcmN0MTBkaWZfZ2VuZXJpYy5jCisrKyBiL2NyeXB0by9jcmN0MTBkaWZfZ2VuZXJpYy5jCkBAIC0xMjUsMyArMTI1LDQgQEAKIE1PRFVMRV9ERVNDUklQVElPTigiVDEwIERJRiBDUkMgY2FsY3VsYXRpb24uIik7CiBNT0RVTEVfTElDRU5TRSgiR1BMIik7CiBNT0RVTEVfQUxJQVNfQ1JZUFRPKCJjcmN0MTBkaWYiKTsKK01PRFVMRV9BTElBU19DUllQVE8oImNyY3QxMGRpZi1nZW5lcmljIik7CmRpZmYgLS1naXQgYS9jcnlwdG8vZGVzX2dlbmVyaWMuYyBiL2NyeXB0by9kZXNfZ2VuZXJpYy5jCmluZGV4IDQyOTEyOTQuLmE3MTcyMDUgMTAwNjQ0Ci0tLSBhL2NyeXB0by9kZXNfZ2VuZXJpYy5jCisrKyBiL2NyeXB0by9kZXNfZ2VuZXJpYy5jCkBAIC05ODMsOCArOTgzLDYgQEAKIAkuY2lhX2RlY3J5cHQJCT0JZGVzM19lZGVfZGVjcnlwdCB9IH0KIH0gfTsKIAotTU9EVUxFX0FMSUFTX0NSWVBUTygiZGVzM19lZGUiKTsKLQogc3RhdGljIGludCBfX2luaXQgZGVzX2dlbmVyaWNfbW9kX2luaXQodm9pZCkKIHsKIAlyZXR1cm4gY3J5cHRvX3JlZ2lzdGVyX2FsZ3MoZGVzX2FsZ3MsIEFSUkFZX1NJWkUoZGVzX2FsZ3MpKTsKQEAgLTEwMDEsNCArOTk5LDcgQEAKIE1PRFVMRV9MSUNFTlNFKCJHUEwiKTsKIE1PRFVMRV9ERVNDUklQVElPTigiREVTICYgVHJpcGxlIERFUyBFREUgQ2lwaGVyIEFsZ29yaXRobXMiKTsKIE1PRFVMRV9BVVRIT1IoIkRhZyBBcm5lIE9zdmlrIDxkYUBvc3Zpay5ubz4iKTsKLU1PRFVMRV9BTElBUygiZGVzIik7CitNT0RVTEVfQUxJQVNfQ1JZUFRPKCJkZXMiKTsKK01PRFVMRV9BTElBU19DUllQVE8oImRlcy1nZW5lcmljIik7CitNT0RVTEVfQUxJQVNfQ1JZUFRPKCJkZXMzX2VkZSIpOworTU9EVUxFX0FMSUFTX0NSWVBUTygiZGVzM19lZGUtZ2VuZXJpYyIpOwpkaWZmIC0tZ2l0IGEvY3J5cHRvL2doYXNoLWdlbmVyaWMuYyBiL2NyeXB0by9naGFzaC1nZW5lcmljLmMKaW5kZXggNGU5N2ZhZS4uYmFjNzA5OSAxMDA2NDQKLS0tIGEvY3J5cHRvL2doYXNoLWdlbmVyaWMuYworKysgYi9jcnlwdG8vZ2hhc2gtZ2VuZXJpYy5jCkBAIC0xNzMsMyArMTczLDQgQEAKIE1PRFVMRV9MSUNFTlNFKCJHUEwiKTsKIE1PRFVMRV9ERVNDUklQVElPTigiR0hBU0ggTWVzc2FnZSBEaWdlc3QgQWxnb3JpdGhtIik7CiBNT0RVTEVfQUxJQVNfQ1JZUFRPKCJnaGFzaCIpOworTU9EVUxFX0FMSUFTX0NSWVBUTygiZ2hhc2gtZ2VuZXJpYyIpOwpkaWZmIC0tZ2l0IGEvY3J5cHRvL2tybmcuYyBiL2NyeXB0by9rcm5nLmMKaW5kZXggNjdjODhiMy4uMDIyNDg0MSAxMDA2NDQKLS0tIGEvY3J5cHRvL2tybmcuYworKysgYi9jcnlwdG8va3JuZy5jCkBAIC02MywzICs2Myw0IEBACiBNT0RVTEVfTElDRU5TRSgiR1BMIik7CiBNT0RVTEVfREVTQ1JJUFRJT04oIktlcm5lbCBSYW5kb20gTnVtYmVyIEdlbmVyYXRvciIpOwogTU9EVUxFX0FMSUFTX0NSWVBUTygic3Rkcm5nIik7CitNT0RVTEVfQUxJQVNfQ1JZUFRPKCJrcm5nIik7CmRpZmYgLS1naXQgYS9jcnlwdG8vc2Fsc2EyMF9nZW5lcmljLmMgYi9jcnlwdG8vc2Fsc2EyMF9nZW5lcmljLmMKaW5kZXggM2QwZjlkZi4uZjU1MGI1ZCAxMDA2NDQKLS0tIGEvY3J5cHRvL3NhbHNhMjBfZ2VuZXJpYy5jCisrKyBiL2NyeXB0by9zYWxzYTIwX2dlbmVyaWMuYwpAQCAtMjQ5LDMgKzI0OSw0IEBACiBNT0RVTEVfTElDRU5TRSgiR1BMIik7CiBNT0RVTEVfREVTQ1JJUFRJT04gKCJTYWxzYTIwIHN0cmVhbSBjaXBoZXIgYWxnb3JpdGhtIik7CiBNT0RVTEVfQUxJQVNfQ1JZUFRPKCJzYWxzYTIwIik7CitNT0RVTEVfQUxJQVNfQ1JZUFRPKCJzYWxzYTIwLWdlbmVyaWMiKTsKZGlmZiAtLWdpdCBhL2NyeXB0by9zZXJwZW50X2dlbmVyaWMuYyBiL2NyeXB0by9zZXJwZW50X2dlbmVyaWMuYwppbmRleCBhNTNiNWUyLi45NDk3MGE3IDEwMDY0NAotLS0gYS9jcnlwdG8vc2VycGVudF9nZW5lcmljLmMKKysrIGIvY3J5cHRvL3NlcnBlbnRfZ2VuZXJpYy5jCkBAIC02NjcsMyArNjY3LDQgQEAKIE1PRFVMRV9BVVRIT1IoIkRhZyBBcm5lIE9zdmlrIDxvc3Zpa0BpaS51aWIubm8+Iik7CiBNT0RVTEVfQUxJQVNfQ1JZUFRPKCJ0bmVwcmVzIik7CiBNT0RVTEVfQUxJQVNfQ1JZUFRPKCJzZXJwZW50Iik7CitNT0RVTEVfQUxJQVNfQ1JZUFRPKCJzZXJwZW50LWdlbmVyaWMiKTsKZGlmZiAtLWdpdCBhL2NyeXB0by9zaGExX2dlbmVyaWMuYyBiL2NyeXB0by9zaGExX2dlbmVyaWMuYwppbmRleCAwMzllNThjLi5hM2U1MGMzIDEwMDY0NAotLS0gYS9jcnlwdG8vc2hhMV9nZW5lcmljLmMKKysrIGIvY3J5cHRvL3NoYTFfZ2VuZXJpYy5jCkBAIC0xNTQsMyArMTU0LDQgQEAKIE1PRFVMRV9ERVNDUklQVElPTigiU0hBMSBTZWN1cmUgSGFzaCBBbGdvcml0aG0iKTsKIAogTU9EVUxFX0FMSUFTX0NSWVBUTygic2hhMSIpOworTU9EVUxFX0FMSUFTX0NSWVBUTygic2hhMS1nZW5lcmljIik7CmRpZmYgLS1naXQgYS9jcnlwdG8vc2hhMjU2X2dlbmVyaWMuYyBiL2NyeXB0by9zaGEyNTZfZ2VuZXJpYy5jCmluZGV4IDVlYjIxYjEuLmIwMDFmZjUgMTAwNjQ0Ci0tLSBhL2NyeXB0by9zaGEyNTZfZ2VuZXJpYy5jCisrKyBiL2NyeXB0by9zaGEyNTZfZ2VuZXJpYy5jCkBAIC0zODUsNCArMzg1LDYgQEAKIE1PRFVMRV9ERVNDUklQVElPTigiU0hBLTIyNCBhbmQgU0hBLTI1NiBTZWN1cmUgSGFzaCBBbGdvcml0aG0iKTsKIAogTU9EVUxFX0FMSUFTX0NSWVBUTygic2hhMjI0Iik7CitNT0RVTEVfQUxJQVNfQ1JZUFRPKCJzaGEyMjQtZ2VuZXJpYyIpOwogTU9EVUxFX0FMSUFTX0NSWVBUTygic2hhMjU2Iik7CitNT0RVTEVfQUxJQVNfQ1JZUFRPKCJzaGEyNTYtZ2VuZXJpYyIpOwpkaWZmIC0tZ2l0IGEvY3J5cHRvL3NoYTUxMl9nZW5lcmljLmMgYi9jcnlwdG8vc2hhNTEyX2dlbmVyaWMuYwppbmRleCA4ZDBiMTllLi4xYzNjMzc2IDEwMDY0NAotLS0gYS9jcnlwdG8vc2hhNTEyX2dlbmVyaWMuYworKysgYi9jcnlwdG8vc2hhNTEyX2dlbmVyaWMuYwpAQCAtMjg5LDQgKzI4OSw2IEBACiBNT0RVTEVfREVTQ1JJUFRJT04oIlNIQS01MTIgYW5kIFNIQS0zODQgU2VjdXJlIEhhc2ggQWxnb3JpdGhtcyIpOwogCiBNT0RVTEVfQUxJQVNfQ1JZUFRPKCJzaGEzODQiKTsKK01PRFVMRV9BTElBU19DUllQVE8oInNoYTM4NC1nZW5lcmljIik7CiBNT0RVTEVfQUxJQVNfQ1JZUFRPKCJzaGE1MTIiKTsKK01PRFVMRV9BTElBU19DUllQVE8oInNoYTUxMi1nZW5lcmljIik7CmRpZmYgLS1naXQgYS9jcnlwdG8vdGVhLmMgYi9jcnlwdG8vdGVhLmMKaW5kZXggNDk1YmUyZC4uYjcwYjQ0MSAxMDA2NDQKLS0tIGEvY3J5cHRvL3RlYS5jCisrKyBiL2NyeXB0by90ZWEuYwpAQCAtMjcwLDYgKzI3MCw3IEBACiAJY3J5cHRvX3VucmVnaXN0ZXJfYWxncyh0ZWFfYWxncywgQVJSQVlfU0laRSh0ZWFfYWxncykpOwogfQogCitNT0RVTEVfQUxJQVNfQ1JZUFRPKCJ0ZWEiKTsKIE1PRFVMRV9BTElBU19DUllQVE8oInh0ZWEiKTsKIE1PRFVMRV9BTElBU19DUllQVE8oInhldGEiKTsKIApkaWZmIC0tZ2l0IGEvY3J5cHRvL3RncjE5Mi5jIGIvY3J5cHRvL3RncjE5Mi5jCmluZGV4IDZlNTY1MWMuLjMyMWJjNmYgMTAwNjQ0Ci0tLSBhL2NyeXB0by90Z3IxOTIuYworKysgYi9jcnlwdG8vdGdyMTkyLmMKQEAgLTY3Niw2ICs2NzYsNyBAQAogCWNyeXB0b191bnJlZ2lzdGVyX3NoYXNoZXModGdyX2FsZ3MsIEFSUkFZX1NJWkUodGdyX2FsZ3MpKTsKIH0KIAorTU9EVUxFX0FMSUFTX0NSWVBUTygidGdyMTkyIik7CiBNT0RVTEVfQUxJQVNfQ1JZUFRPKCJ0Z3IxNjAiKTsKIE1PRFVMRV9BTElBU19DUllQVE8oInRncjEyOCIpOwogCmRpZmYgLS1naXQgYS9jcnlwdG8vdHdvZmlzaF9nZW5lcmljLmMgYi9jcnlwdG8vdHdvZmlzaF9nZW5lcmljLmMKaW5kZXggNTIzYWQ4Yy4uZWJmN2EzZSAxMDA2NDQKLS0tIGEvY3J5cHRvL3R3b2Zpc2hfZ2VuZXJpYy5jCisrKyBiL2NyeXB0by90d29maXNoX2dlbmVyaWMuYwpAQCAtMjEyLDMgKzIxMiw0IEBACiBNT0RVTEVfTElDRU5TRSgiR1BMIik7CiBNT0RVTEVfREVTQ1JJUFRJT04gKCJUd29maXNoIENpcGhlciBBbGdvcml0aG0iKTsKIE1PRFVMRV9BTElBU19DUllQVE8oInR3b2Zpc2giKTsKK01PRFVMRV9BTElBU19DUllQVE8oInR3b2Zpc2gtZ2VuZXJpYyIpOwpkaWZmIC0tZ2l0IGEvY3J5cHRvL3dwNTEyLmMgYi9jcnlwdG8vd3A1MTIuYwppbmRleCAwZGU0MmViLi43ZWU1YTA0IDEwMDY0NAotLS0gYS9jcnlwdG8vd3A1MTIuYworKysgYi9jcnlwdG8vd3A1MTIuYwpAQCAtMTE2Nyw2ICsxMTY3LDcgQEAKIAljcnlwdG9fdW5yZWdpc3Rlcl9zaGFzaGVzKHdwX2FsZ3MsIEFSUkFZX1NJWkUod3BfYWxncykpOwogfQogCitNT0RVTEVfQUxJQVNfQ1JZUFRPKCJ3cDUxMiIpOwogTU9EVUxFX0FMSUFTX0NSWVBUTygid3AzODQiKTsKIE1PRFVMRV9BTElBU19DUllQVE8oIndwMjU2Iik7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvS2NvbmZpZyBiL2RyaXZlcnMvS2NvbmZpZwppbmRleCA2OTRkNWE3Li5jNzBkNmU0IDEwMDY0NAotLS0gYS9kcml2ZXJzL0tjb25maWcKKysrIGIvZHJpdmVycy9LY29uZmlnCkBAIC0xMzQsOCArMTM0LDYgQEAKIAogc291cmNlICJkcml2ZXJzL3BsYXRmb3JtL0tjb25maWciCiAKLXNvdXJjZSAiZHJpdmVycy9zb2MvS2NvbmZpZyIKLQogc291cmNlICJkcml2ZXJzL2Nsay9LY29uZmlnIgogCiBzb3VyY2UgImRyaXZlcnMvaHdzcGlubG9jay9LY29uZmlnIgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL0tjb25maWcgYi9kcml2ZXJzL2FjcGkvS2NvbmZpZwppbmRleCA4OTUxY2VmYi4uZTZjM2RkZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL0tjb25maWcKKysrIGIvZHJpdmVycy9hY3BpL0tjb25maWcKQEAgLTMxNSw2ICszMTUsMTIgQEAKIAkgIFRvIGNvbXBpbGUgdGhpcyBkcml2ZXIgYXMgYSBtb2R1bGUsIGNob29zZSBNIGhlcmU6CiAJICB0aGUgbW9kdWxlIHdpbGwgYmUgY2FsbGVkIGFjcGlfbWVtaG90cGx1Zy4KIAorY29uZmlnIEFDUElfSE9UUExVR19JT0FQSUMKKwlib29sCisJZGVwZW5kcyBvbiBQQ0kKKwlkZXBlbmRzIG9uIFg4Nl9JT19BUElDCisJZGVmYXVsdCB5CisKIGNvbmZpZyBBQ1BJX1NCUwogCXRyaXN0YXRlICJTbWFydCBCYXR0ZXJ5IFN5c3RlbSIKIAlkZXBlbmRzIG9uIFg4NgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL01ha2VmaWxlIGIvZHJpdmVycy9hY3BpL01ha2VmaWxlCmluZGV4IGY3NDMxN2MuLmIxOGNkMjEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9NYWtlZmlsZQorKysgYi9kcml2ZXJzL2FjcGkvTWFrZWZpbGUKQEAgLTQwLDcgKzQwLDcgQEAKIGFjcGkteQkJCQkrPSBlYy5vCiBhY3BpLSQoQ09ORklHX0FDUElfRE9DSykJKz0gZG9jay5vCiBhY3BpLXkJCQkJKz0gcGNpX3Jvb3QubyBwY2lfbGluay5vIHBjaV9pcnEubwotYWNwaS15CQkJCSs9IGFjcGlfbHBzcy5vCithY3BpLXkJCQkJKz0gYWNwaV9scHNzLm8gYWNwaV9hcGQubwogYWNwaS15CQkJCSs9IGFjcGlfcGxhdGZvcm0ubwogYWNwaS15CQkJCSs9IGFjcGlfcG5wLm8KIGFjcGkteQkJCQkrPSBpbnQzNDB4X3RoZXJtYWwubwpAQCAtNzAsNiArNzAsNyBAQAogb2JqLXkJCQkJKz0gY29udGFpbmVyLm8KIG9iai0kKENPTkZJR19BQ1BJX1RIRVJNQUwpCSs9IHRoZXJtYWwubwogb2JqLXkJCQkJKz0gYWNwaV9tZW1ob3RwbHVnLm8KK29iai0kKENPTkZJR19BQ1BJX0hPVFBMVUdfSU9BUElDKSArPSBpb2FwaWMubwogb2JqLSQoQ09ORklHX0FDUElfQkFUVEVSWSkJKz0gYmF0dGVyeS5vCiBvYmotJChDT05GSUdfQUNQSV9TQlMpCQkrPSBzYnNoYy5vCiBvYmotJChDT05GSUdfQUNQSV9TQlMpCQkrPSBzYnMubwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGlfYXBkLmMgYi9kcml2ZXJzL2FjcGkvYWNwaV9hcGQuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zOTg0ZWE5Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9hY3BpL2FjcGlfYXBkLmMKQEAgLTAsMCArMSwxNTAgQEAKKy8qCisgKiBBTUQgQUNQSSBzdXBwb3J0IGZvciBBQ1BJMnBsYXRmb3JtIGRldmljZS4KKyAqCisgKiBDb3B5cmlnaHQgKGMpIDIwMTQsMjAxNSBBTUQgQ29ycG9yYXRpb24uCisgKiBBdXRob3JzOiBLZW4gWHVlIDxLZW4uWHVlQGFtZC5jb20+CisgKglXdSwgSmVmZiA8SmVmZi5XdUBhbWQuY29tPgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisgKi8KKworI2luY2x1ZGUgPGxpbnV4L2Nsay1wcm92aWRlci5oPgorI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L3BtX2RvbWFpbi5oPgorI2luY2x1ZGUgPGxpbnV4L2Nsa2Rldi5oPgorI2luY2x1ZGUgPGxpbnV4L2FjcGkuaD4KKyNpbmNsdWRlIDxsaW51eC9lcnIuaD4KKyNpbmNsdWRlIDxsaW51eC9jbGsuaD4KKyNpbmNsdWRlIDxsaW51eC9wbS5oPgorCisjaW5jbHVkZSAiaW50ZXJuYWwuaCIKKworQUNQSV9NT0RVTEVfTkFNRSgiYWNwaV9hcGQiKTsKK3N0cnVjdCBhcGRfcHJpdmF0ZV9kYXRhOworCisvKioKKyAqIEFDUElfQVBEX1NZU0ZTIDogYWRkIGRldmljZSBhdHRyaWJ1dGVzIGluIHN5c2ZzCisgKiBBQ1BJX0FQRF9QTSA6IGF0dGFjaCBwb3dlciBkb21haW4gdG8gZGV2aWNlCisgKi8KKyNkZWZpbmUgQUNQSV9BUERfU1lTRlMJQklUKDApCisjZGVmaW5lIEFDUElfQVBEX1BNCUJJVCgxKQorCisvKioKKyAqIHN0cnVjdCBhcGRfZGV2aWNlX2Rlc2MgLSBhIGRlc2NyaXB0b3IgZm9yIGFwZCBkZXZpY2UKKyAqIEBmbGFnczogZGV2aWNlIGZsYWdzIGxpa2UgJUFDUElfQVBEX1NZU0ZTLCAlQUNQSV9BUERfUE0KKyAqIEBmaXhlZF9jbGtfcmF0ZTogZml4ZWQgcmF0ZSBpbnB1dCBjbG9jayBzb3VyY2UgZm9yIGFjcGkgZGV2aWNlOworICoJCQkwIG1lYW5zIG5vIGZpeGVkIHJhdGUgaW5wdXQgY2xvY2sgc291cmNlCisgKiBAc2V0dXA6IGEgaG9vayByb3V0aW5lIHRvIHNldCBkZXZpY2UgcmVzb3VyY2UgZHVyaW5nIGNyZWF0ZSBwbGF0Zm9ybSBkZXZpY2UKKyAqCisgKiBEZXZpY2UgZGVzY3JpcHRpb24gZGVmaW5lZCBhcyBhY3BpX2RldmljZV9pZC5kcml2ZXJfZGF0YQorICovCitzdHJ1Y3QgYXBkX2RldmljZV9kZXNjIHsKKwl1bnNpZ25lZCBpbnQgZmxhZ3M7CisJdW5zaWduZWQgaW50IGZpeGVkX2Nsa19yYXRlOworCWludCAoKnNldHVwKShzdHJ1Y3QgYXBkX3ByaXZhdGVfZGF0YSAqcGRhdGEpOworfTsKKworc3RydWN0IGFwZF9wcml2YXRlX2RhdGEgeworCXN0cnVjdCBjbGsgKmNsazsKKwlzdHJ1Y3QgYWNwaV9kZXZpY2UgKmFkZXY7CisJY29uc3Qgc3RydWN0IGFwZF9kZXZpY2VfZGVzYyAqZGV2X2Rlc2M7Cit9OworCisjaWZkZWYgQ09ORklHX1g4Nl9BTURfUExBVEZPUk1fREVWSUNFCisjZGVmaW5lIEFQRF9BRERSKGRlc2MpCSgodW5zaWduZWQgbG9uZykmZGVzYykKKworc3RhdGljIGludCBhY3BpX2FwZF9zZXR1cChzdHJ1Y3QgYXBkX3ByaXZhdGVfZGF0YSAqcGRhdGEpCit7CisJY29uc3Qgc3RydWN0IGFwZF9kZXZpY2VfZGVzYyAqZGV2X2Rlc2MgPSBwZGF0YS0+ZGV2X2Rlc2M7CisJc3RydWN0IGNsayAqY2xrID0gRVJSX1BUUigtRU5PREVWKTsKKworCWlmIChkZXZfZGVzYy0+Zml4ZWRfY2xrX3JhdGUpIHsKKwkJY2xrID0gY2xrX3JlZ2lzdGVyX2ZpeGVkX3JhdGUoJnBkYXRhLT5hZGV2LT5kZXYsCisJCQkJCWRldl9uYW1lKCZwZGF0YS0+YWRldi0+ZGV2KSwKKwkJCQkJTlVMTCwgQ0xLX0lTX1JPT1QsCisJCQkJCWRldl9kZXNjLT5maXhlZF9jbGtfcmF0ZSk7CisJCWNsa19yZWdpc3Rlcl9jbGtkZXYoY2xrLCBOVUxMLCBkZXZfbmFtZSgmcGRhdGEtPmFkZXYtPmRldikpOworCQlwZGF0YS0+Y2xrID0gY2xrOworCX0KKworCXJldHVybiAwOworfQorCitzdGF0aWMgc3RydWN0IGFwZF9kZXZpY2VfZGVzYyBjel9pMmNfZGVzYyA9IHsKKwkuc2V0dXAgPSBhY3BpX2FwZF9zZXR1cCwKKwkuZml4ZWRfY2xrX3JhdGUgPSAxMzMwMDAwMDAsCit9OworCitzdGF0aWMgc3RydWN0IGFwZF9kZXZpY2VfZGVzYyBjel91YXJ0X2Rlc2MgPSB7CisJLnNldHVwID0gYWNwaV9hcGRfc2V0dXAsCisJLmZpeGVkX2Nsa19yYXRlID0gNDgwMDAwMDAsCit9OworCisjZWxzZQorCisjZGVmaW5lIEFQRF9BRERSKGRlc2MpICgwVUwpCisKKyNlbmRpZiAvKiBDT05GSUdfWDg2X0FNRF9QTEFURk9STV9ERVZJQ0UgKi8KKworLyoqCisqIENyZWF0ZSBwbGF0Zm9ybSBkZXZpY2UgZHVyaW5nIGFjcGkgc2NhbiBhdHRhY2ggaGFuZGxlLgorKiBSZXR1cm4gdmFsdWUgPiAwIG9uIHN1Y2Nlc3Mgb2YgY3JlYXRpbmcgZGV2aWNlLgorKi8KK3N0YXRpYyBpbnQgYWNwaV9hcGRfY3JlYXRlX2RldmljZShzdHJ1Y3QgYWNwaV9kZXZpY2UgKmFkZXYsCisJCQkJICAgY29uc3Qgc3RydWN0IGFjcGlfZGV2aWNlX2lkICppZCkKK3sKKwljb25zdCBzdHJ1Y3QgYXBkX2RldmljZV9kZXNjICpkZXZfZGVzYyA9ICh2b2lkICopaWQtPmRyaXZlcl9kYXRhOworCXN0cnVjdCBhcGRfcHJpdmF0ZV9kYXRhICpwZGF0YTsKKwlzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2OworCWludCByZXQ7CisKKwlpZiAoIWRldl9kZXNjKSB7CisJCXBkZXYgPSBhY3BpX2NyZWF0ZV9wbGF0Zm9ybV9kZXZpY2UoYWRldik7CisJCXJldHVybiBJU19FUlJfT1JfTlVMTChwZGV2KSA/IFBUUl9FUlIocGRldikgOiAxOworCX0KKworCXBkYXRhID0ga3phbGxvYyhzaXplb2YoKnBkYXRhKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFwZGF0YSkKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlwZGF0YS0+YWRldiA9IGFkZXY7CisJcGRhdGEtPmRldl9kZXNjID0gZGV2X2Rlc2M7CisKKwlpZiAoZGV2X2Rlc2MtPnNldHVwKSB7CisJCXJldCA9IGRldl9kZXNjLT5zZXR1cChwZGF0YSk7CisJCWlmIChyZXQpCisJCQlnb3RvIGVycl9vdXQ7CisJfQorCisJYWRldi0+ZHJpdmVyX2RhdGEgPSBwZGF0YTsKKwlwZGV2ID0gYWNwaV9jcmVhdGVfcGxhdGZvcm1fZGV2aWNlKGFkZXYpOworCWlmICghSVNfRVJSX09SX05VTEwocGRldikpCisJCXJldHVybiAxOworCisJcmV0ID0gUFRSX0VSUihwZGV2KTsKKwlhZGV2LT5kcml2ZXJfZGF0YSA9IE5VTEw7CisKKyBlcnJfb3V0OgorCWtmcmVlKHBkYXRhKTsKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IGFjcGlfZGV2aWNlX2lkIGFjcGlfYXBkX2RldmljZV9pZHNbXSA9IHsKKwkvKiBHZW5lcmljIGFwZCBkZXZpY2VzICovCisJeyAiQU1EMDAxMCIsIEFQRF9BRERSKGN6X2kyY19kZXNjKSB9LAorCXsgIkFNRDAwMjAiLCBBUERfQUREUihjel91YXJ0X2Rlc2MpIH0sCisJeyAiQU1EMDAzMCIsIH0sCisJeyB9Cit9OworCitzdGF0aWMgc3RydWN0IGFjcGlfc2Nhbl9oYW5kbGVyIGFwZF9oYW5kbGVyID0geworCS5pZHMgPSBhY3BpX2FwZF9kZXZpY2VfaWRzLAorCS5hdHRhY2ggPSBhY3BpX2FwZF9jcmVhdGVfZGV2aWNlLAorfTsKKwordm9pZCBfX2luaXQgYWNwaV9hcGRfaW5pdCh2b2lkKQoreworCWFjcGlfc2Nhbl9hZGRfaGFuZGxlcigmYXBkX2hhbmRsZXIpOworfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGlfbHBzcy5jIGIvZHJpdmVycy9hY3BpL2FjcGlfbHBzcy5jCmluZGV4IDRmM2ZlYmYuLjAyZTgzNWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpX2xwc3MuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaV9scHNzLmMKQEAgLTEsNyArMSw3IEBACiAvKgogICogQUNQSSBzdXBwb3J0IGZvciBJbnRlbCBMeW54cG9pbnQgTFBTUy4KICAqCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTMsIDIwMTQsIEludGVsIENvcnBvcmF0aW9uCisgKiBDb3B5cmlnaHQgKEMpIDIwMTMsIEludGVsIENvcnBvcmF0aW9uCiAgKiBBdXRob3JzOiBNaWthIFdlc3RlcmJlcmcgPG1pa2Eud2VzdGVyYmVyZ0BsaW51eC5pbnRlbC5jb20+CiAgKiAgICAgICAgICBSYWZhZWwgSi4gV3lzb2NraSA8cmFmYWVsLmoud3lzb2NraUBpbnRlbC5jb20+CiAgKgpAQCAtNjAsOCArNjAsNiBAQAogI2RlZmluZSBMUFNTX0NMS19ESVZJREVSCQlCSVQoMikKICNkZWZpbmUgTFBTU19MVFIJCQlCSVQoMykKICNkZWZpbmUgTFBTU19TQVZFX0NUWAkJCUJJVCg0KQotI2RlZmluZSBMUFNTX0RFVl9QUk9YWQkJCUJJVCg1KQotI2RlZmluZSBMUFNTX1BST1hZX1JFUQkJCUJJVCg2KQogCiBzdHJ1Y3QgbHBzc19wcml2YXRlX2RhdGE7CiAKQEAgLTcyLDEwICs3MCw4IEBACiAJdm9pZCAoKnNldHVwKShzdHJ1Y3QgbHBzc19wcml2YXRlX2RhdGEgKnBkYXRhKTsKIH07CiAKLXN0YXRpYyBzdHJ1Y3QgZGV2aWNlICpwcm94eV9kZXZpY2U7Ci0KIHN0YXRpYyBzdHJ1Y3QgbHBzc19kZXZpY2VfZGVzYyBscHNzX2RtYV9kZXNjID0gewotCS5mbGFncyA9IExQU1NfQ0xLIHwgTFBTU19QUk9YWV9SRVEsCisJLmZsYWdzID0gTFBTU19DTEssCiB9OwogCiBzdHJ1Y3QgbHBzc19wcml2YXRlX2RhdGEgewpAQCAtMTI5LDcgKzEyNSw3IEBACiB9OwogCiBzdGF0aWMgc3RydWN0IGxwc3NfZGV2aWNlX2Rlc2MgbHB0X2kyY19kZXZfZGVzYyA9IHsKLQkuZmxhZ3MgPSBMUFNTX0NMSyB8IExQU1NfQ0xLX0dBVEUgfCBMUFNTX0xUUiwKKwkuZmxhZ3MgPSBMUFNTX0NMSyB8IExQU1NfTFRSLAogCS5wcnZfb2Zmc2V0ID0gMHg4MDAsCiB9OwogCkBAIC0xNTAsMjQgKzE0NiwyMiBAQAogfTsKIAogc3RhdGljIHN0cnVjdCBscHNzX2RldmljZV9kZXNjIGJ5dF91YXJ0X2Rldl9kZXNjID0gewotCS5mbGFncyA9IExQU1NfQ0xLIHwgTFBTU19DTEtfR0FURSB8IExQU1NfQ0xLX0RJVklERVIgfCBMUFNTX1NBVkVfQ1RYIHwKLQkJIExQU1NfREVWX1BST1hZLAorCS5mbGFncyA9IExQU1NfQ0xLIHwgTFBTU19DTEtfR0FURSB8IExQU1NfQ0xLX0RJVklERVIgfCBMUFNTX1NBVkVfQ1RYLAogCS5wcnZfb2Zmc2V0ID0gMHg4MDAsCiAJLnNldHVwID0gbHBzc191YXJ0X3NldHVwLAogfTsKIAogc3RhdGljIHN0cnVjdCBscHNzX2RldmljZV9kZXNjIGJ5dF9zcGlfZGV2X2Rlc2MgPSB7Ci0JLmZsYWdzID0gTFBTU19DTEsgfCBMUFNTX0NMS19HQVRFIHwgTFBTU19DTEtfRElWSURFUiB8IExQU1NfU0FWRV9DVFggfAotCQkgTFBTU19ERVZfUFJPWFksCisJLmZsYWdzID0gTFBTU19DTEsgfCBMUFNTX0NMS19HQVRFIHwgTFBTU19DTEtfRElWSURFUiB8IExQU1NfU0FWRV9DVFgsCiAJLnBydl9vZmZzZXQgPSAweDQwMCwKIH07CiAKIHN0YXRpYyBzdHJ1Y3QgbHBzc19kZXZpY2VfZGVzYyBieXRfc2Rpb19kZXZfZGVzYyA9IHsKLQkuZmxhZ3MgPSBMUFNTX0NMSyB8IExQU1NfREVWX1BST1hZLAorCS5mbGFncyA9IExQU1NfQ0xLLAogfTsKIAogc3RhdGljIHN0cnVjdCBscHNzX2RldmljZV9kZXNjIGJ5dF9pMmNfZGV2X2Rlc2MgPSB7Ci0JLmZsYWdzID0gTFBTU19DTEsgfCBMUFNTX1NBVkVfQ1RYIHwgTFBTU19ERVZfUFJPWFksCisJLmZsYWdzID0gTFBTU19DTEsgfCBMUFNTX1NBVkVfQ1RYLAogCS5wcnZfb2Zmc2V0ID0gMHg4MDAsCiAJLnNldHVwID0gYnl0X2kyY19zZXR1cCwKIH07CkBAIC0zMTMsNyArMzA3LDcgQEAKIHsKIAlzdHJ1Y3QgbHBzc19kZXZpY2VfZGVzYyAqZGV2X2Rlc2M7CiAJc3RydWN0IGxwc3NfcHJpdmF0ZV9kYXRhICpwZGF0YTsKLQlzdHJ1Y3QgcmVzb3VyY2VfbGlzdF9lbnRyeSAqcmVudHJ5OworCXN0cnVjdCByZXNvdXJjZV9lbnRyeSAqcmVudHJ5OwogCXN0cnVjdCBsaXN0X2hlYWQgcmVzb3VyY2VfbGlzdDsKIAlzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2OwogCWludCByZXQ7CkBAIC0zMzMsMTMgKzMyNywxNSBAQAogCQlnb3RvIGVycl9vdXQ7CiAKIAlsaXN0X2Zvcl9lYWNoX2VudHJ5KHJlbnRyeSwgJnJlc291cmNlX2xpc3QsIG5vZGUpCi0JCWlmIChyZXNvdXJjZV90eXBlKCZyZW50cnktPnJlcykgPT0gSU9SRVNPVVJDRV9NRU0pIHsKKwkJaWYgKHJlc291cmNlX3R5cGUocmVudHJ5LT5yZXMpID09IElPUkVTT1VSQ0VfTUVNKSB7CiAJCQlpZiAoZGV2X2Rlc2MtPnBydl9zaXplX292ZXJyaWRlKQogCQkJCXBkYXRhLT5tbWlvX3NpemUgPSBkZXZfZGVzYy0+cHJ2X3NpemVfb3ZlcnJpZGU7CiAJCQllbHNlCi0JCQkJcGRhdGEtPm1taW9fc2l6ZSA9IHJlc291cmNlX3NpemUoJnJlbnRyeS0+cmVzKTsKLQkJCXBkYXRhLT5tbWlvX2Jhc2UgPSBpb3JlbWFwKHJlbnRyeS0+cmVzLnN0YXJ0LAorCQkJCXBkYXRhLT5tbWlvX3NpemUgPSByZXNvdXJjZV9zaXplKHJlbnRyeS0+cmVzKTsKKwkJCXBkYXRhLT5tbWlvX2Jhc2UgPSBpb3JlbWFwKHJlbnRyeS0+cmVzLT5zdGFydCwKIAkJCQkJCSAgIHBkYXRhLT5tbWlvX3NpemUpOworCQkJaWYgKCFwZGF0YS0+bW1pb19iYXNlKQorCQkJCWdvdG8gZXJyX291dDsKIAkJCWJyZWFrOwogCQl9CiAKQEAgLTM3NCw4ICszNzAsNiBAQAogCWFkZXYtPmRyaXZlcl9kYXRhID0gcGRhdGE7CiAJcGRldiA9IGFjcGlfY3JlYXRlX3BsYXRmb3JtX2RldmljZShhZGV2KTsKIAlpZiAoIUlTX0VSUl9PUl9OVUxMKHBkZXYpKSB7Ci0JCWlmICghcHJveHlfZGV2aWNlICYmIGRldl9kZXNjLT5mbGFncyAmIExQU1NfREVWX1BST1hZKQotCQkJcHJveHlfZGV2aWNlID0gJnBkZXYtPmRldjsKIAkJcmV0dXJuIDE7CiAJfQogCkBAIC02MDAsMTQgKzU5NCw3IEBACiAJaWYgKHBkYXRhLT5kZXZfZGVzYy0+ZmxhZ3MgJiBMUFNTX1NBVkVfQ1RYKQogCQlhY3BpX2xwc3Nfc2F2ZV9jdHgoZGV2LCBwZGF0YSk7CiAKLQlyZXQgPSBhY3BpX2Rldl9ydW50aW1lX3N1c3BlbmQoZGV2KTsKLQlpZiAocmV0KQotCQlyZXR1cm4gcmV0OwotCi0JaWYgKHBkYXRhLT5kZXZfZGVzYy0+ZmxhZ3MgJiBMUFNTX1BST1hZX1JFUSAmJiBwcm94eV9kZXZpY2UpCi0JCXJldHVybiBwbV9ydW50aW1lX3B1dF9zeW5jX3N1c3BlbmQocHJveHlfZGV2aWNlKTsKLQotCXJldHVybiAwOworCXJldHVybiBhY3BpX2Rldl9ydW50aW1lX3N1c3BlbmQoZGV2KTsKIH0KIAogc3RhdGljIGludCBhY3BpX2xwc3NfcnVudGltZV9yZXN1bWUoc3RydWN0IGRldmljZSAqZGV2KQpAQCAtNjE1LDEyICs2MDIsNiBAQAogCXN0cnVjdCBscHNzX3ByaXZhdGVfZGF0YSAqcGRhdGEgPSBhY3BpX2RyaXZlcl9kYXRhKEFDUElfQ09NUEFOSU9OKGRldikpOwogCWludCByZXQ7CiAKLQlpZiAocGRhdGEtPmRldl9kZXNjLT5mbGFncyAmIExQU1NfUFJPWFlfUkVRICYmIHByb3h5X2RldmljZSkgewotCQlyZXQgPSBwbV9ydW50aW1lX2dldF9zeW5jKHByb3h5X2RldmljZSk7Ci0JCWlmIChyZXQpCi0JCQlyZXR1cm4gcmV0OwotCX0KLQogCXJldCA9IGFjcGlfZGV2X3J1bnRpbWVfcmVzdW1lKGRldik7CiAJaWYgKHJldCkKIAkJcmV0dXJuIHJldDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpX21lbWhvdHBsdWcuYyBiL2RyaXZlcnMvYWNwaS9hY3BpX21lbWhvdHBsdWcuYwppbmRleCAyM2UyMzE5Li5lZTI4ZjRkIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaV9tZW1ob3RwbHVnLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGlfbWVtaG90cGx1Zy5jCkBAIC0xMDEsOCArMTAxLDggQEAKIAkJLyogQ2FuIHdlIGNvbWJpbmUgdGhlIHJlc291cmNlIHJhbmdlIGluZm9ybWF0aW9uPyAqLwogCQlpZiAoKGluZm8tPmNhY2hpbmcgPT0gYWRkcmVzczY0LmluZm8ubWVtLmNhY2hpbmcpICYmCiAJCSAgICAoaW5mby0+d3JpdGVfcHJvdGVjdCA9PSBhZGRyZXNzNjQuaW5mby5tZW0ud3JpdGVfcHJvdGVjdCkgJiYKLQkJICAgIChpbmZvLT5zdGFydF9hZGRyICsgaW5mby0+bGVuZ3RoID09IGFkZHJlc3M2NC5taW5pbXVtKSkgewotCQkJaW5mby0+bGVuZ3RoICs9IGFkZHJlc3M2NC5hZGRyZXNzX2xlbmd0aDsKKwkJICAgIChpbmZvLT5zdGFydF9hZGRyICsgaW5mby0+bGVuZ3RoID09IGFkZHJlc3M2NC5hZGRyZXNzLm1pbmltdW0pKSB7CisJCQlpbmZvLT5sZW5ndGggKz0gYWRkcmVzczY0LmFkZHJlc3MuYWRkcmVzc19sZW5ndGg7CiAJCQlyZXR1cm4gQUVfT0s7CiAJCX0KIAl9CkBAIC0xMTQsOCArMTE0LDggQEAKIAlJTklUX0xJU1RfSEVBRCgmbmV3LT5saXN0KTsKIAluZXctPmNhY2hpbmcgPSBhZGRyZXNzNjQuaW5mby5tZW0uY2FjaGluZzsKIAluZXctPndyaXRlX3Byb3RlY3QgPSBhZGRyZXNzNjQuaW5mby5tZW0ud3JpdGVfcHJvdGVjdDsKLQluZXctPnN0YXJ0X2FkZHIgPSBhZGRyZXNzNjQubWluaW11bTsKLQluZXctPmxlbmd0aCA9IGFkZHJlc3M2NC5hZGRyZXNzX2xlbmd0aDsKKwluZXctPnN0YXJ0X2FkZHIgPSBhZGRyZXNzNjQuYWRkcmVzcy5taW5pbXVtOworCW5ldy0+bGVuZ3RoID0gYWRkcmVzczY0LmFkZHJlc3MuYWRkcmVzc19sZW5ndGg7CiAJbGlzdF9hZGRfdGFpbCgmbmV3LT5saXN0LCAmbWVtX2RldmljZS0+cmVzX2xpc3QpOwogCiAJcmV0dXJuIEFFX09LOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGlfcGxhdGZvcm0uYyBiL2RyaXZlcnMvYWNwaS9hY3BpX3BsYXRmb3JtLmMKaW5kZXggNmJhOGJlYi4uMTI4NDEzOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGlfcGxhdGZvcm0uYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaV9wbGF0Zm9ybS5jCkBAIC00NSw3ICs0NSw3IEBACiAJc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiA9IE5VTEw7CiAJc3RydWN0IGFjcGlfZGV2aWNlICphY3BpX3BhcmVudDsKIAlzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlX2luZm8gcGRldmluZm87Ci0Jc3RydWN0IHJlc291cmNlX2xpc3RfZW50cnkgKnJlbnRyeTsKKwlzdHJ1Y3QgcmVzb3VyY2VfZW50cnkgKnJlbnRyeTsKIAlzdHJ1Y3QgbGlzdF9oZWFkIHJlc291cmNlX2xpc3Q7CiAJc3RydWN0IHJlc291cmNlICpyZXNvdXJjZXMgPSBOVUxMOwogCWludCBjb3VudDsKQEAgLTcxLDcgKzcxLDcgQEAKIAkJfQogCQljb3VudCA9IDA7CiAJCWxpc3RfZm9yX2VhY2hfZW50cnkocmVudHJ5LCAmcmVzb3VyY2VfbGlzdCwgbm9kZSkKLQkJCXJlc291cmNlc1tjb3VudCsrXSA9IHJlbnRyeS0+cmVzOworCQkJcmVzb3VyY2VzW2NvdW50KytdID0gKnJlbnRyeS0+cmVzOwogCiAJCWFjcGlfZGV2X2ZyZWVfcmVzb3VyY2VfbGlzdCgmcmVzb3VyY2VfbGlzdCk7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9hY2FwcHMuaCBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNhcHBzLmgKaW5kZXggM2QyYzg4Mi4uZDg2MzAxNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9hY2FwcHMuaAorKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjYXBwcy5oCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApAQCAtNDcsNyArNDcsNyBAQAogLyogQ29tbW9uIGluZm8gZm9yIHRvb2wgc2lnbm9ucyAqLwogCiAjZGVmaW5lIEFDUElDQV9OQU1FICAgICAgICAgICAgICAgICAiSW50ZWwgQUNQSSBDb21wb25lbnQgQXJjaGl0ZWN0dXJlIgotI2RlZmluZSBBQ1BJQ0FfQ09QWVJJR0hUICAgICAgICAgICAgIkNvcHlyaWdodCAoYykgMjAwMCAtIDIwMTQgSW50ZWwgQ29ycG9yYXRpb24iCisjZGVmaW5lIEFDUElDQV9DT1BZUklHSFQgICAgICAgICAgICAiQ29weXJpZ2h0IChjKSAyMDAwIC0gMjAxNSBJbnRlbCBDb3Jwb3JhdGlvbiIKIAogI2lmIEFDUElfTUFDSElORV9XSURUSCA9PSA2NAogI2RlZmluZSBBQ1BJX1dJRFRIICAgICAgICAgICItNjQiCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjY29tbW9uLmggYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjY29tbW9uLmgKaW5kZXggNmYxYzYxNi4uODUzYWEyZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9hY2NvbW1vbi5oCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNjb21tb24uaApAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNkZWJ1Zy5oIGIvZHJpdmVycy9hY3BpL2FjcGljYS9hY2RlYnVnLmgKaW5kZXggMWQwMjZmZi4uNDE2OWJiOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9hY2RlYnVnLmgKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9hY2RlYnVnLmgKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjZGlzcGF0LmggYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjZGlzcGF0LmgKaW5kZXggZDNlMmNjMy4uNDA4ZjA0YiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9hY2Rpc3BhdC5oCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNkaXNwYXQuaApAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNldmVudHMuaCBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNldmVudHMuaAppbmRleCA3YTc4MTFhLi4yMjg3MDRiNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9hY2V2ZW50cy5oCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNldmVudHMuaApAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKQEAgLTE0Myw4ICsxNDMsNiBAQAogYWNwaV9zdGF0dXMKIGFjcGlfZXZfd2Fsa19ncGVfbGlzdChhY3BpX2dwZV9jYWxsYmFjayBncGVfd2Fsa19jYWxsYmFjaywgdm9pZCAqY29udGV4dCk7CiAKLXU4IGFjcGlfZXZfdmFsaWRfZ3BlX2V2ZW50KHN0cnVjdCBhY3BpX2dwZV9ldmVudF9pbmZvICpncGVfZXZlbnRfaW5mbyk7Ci0KIGFjcGlfc3RhdHVzCiBhY3BpX2V2X2dldF9ncGVfZGV2aWNlKHN0cnVjdCBhY3BpX2dwZV94cnVwdF9pbmZvICpncGVfeHJ1cHRfaW5mbywKIAkJICAgICAgIHN0cnVjdCBhY3BpX2dwZV9ibG9ja19pbmZvICpncGVfYmxvY2ssIHZvaWQgKmNvbnRleHQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9hY2dsb2JhbC5oIGIvZHJpdmVycy9hY3BpL2FjcGljYS9hY2dsb2JhbC5oCmluZGV4IDdmNjA1ODIuLmExNjVkMjUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNnbG9iYWwuaAorKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjZ2xvYmFsLmgKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjaHdhcmUuaCBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNod2FyZS5oCmluZGV4IGMzMThkM2UuLjE5NmE1NTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNod2FyZS5oCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNod2FyZS5oCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9hY2ludGVycC5oIGIvZHJpdmVycy9hY3BpL2FjcGljYS9hY2ludGVycC5oCmluZGV4IGIwMWY3MWMuLjE4ODZiZGUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNpbnRlcnAuaAorKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjaW50ZXJwLmgKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjbG9jYWwuaCBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNsb2NhbC5oCmluZGV4IDY4MGQyM2IuLjdhZGQzMmUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNsb2NhbC5oCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNsb2NhbC5oCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9hY21hY3Jvcy5oIGIvZHJpdmVycy9hY3BpL2FjcGljYS9hY21hY3Jvcy5oCmluZGV4IDRiY2ViMTEuLmNmNjA3ZmUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNtYWNyb3MuaAorKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjbWFjcm9zLmgKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjbmFtZXNwLmggYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjbmFtZXNwLmgKaW5kZXggZWUxYzA0MC4uOTUyZmJlMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9hY25hbWVzcC5oCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNuYW1lc3AuaApAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNvYmplY3QuaCBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNvYmplY3QuaAppbmRleCA4YWJiMzkzLi4zZTk3MjBlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2Fjb2JqZWN0LmgKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9hY29iamVjdC5oCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9hY29wY29kZS5oIGIvZHJpdmVycy9hY3BpL2FjcGljYS9hY29wY29kZS5oCmluZGV4IGRkYTBlNmEuLmE1ZjE3ZGUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNvcGNvZGUuaAorKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2Fjb3Bjb2RlLmgKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjcGFyc2VyLmggYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjcGFyc2VyLmgKaW5kZXggNjE2OGI4NS4uNzRhMzkwYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9hY3BhcnNlci5oCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNwYXJzZXIuaApAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNwcmVkZWYuaCBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNwcmVkZWYuaAppbmRleCBiZDM5MDhkLi5hOTcyZDExIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjcHJlZGVmLmgKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9hY3ByZWRlZi5oCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9hY3Jlc3JjLmggYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjcmVzcmMuaAppbmRleCA0YjAwOGU4Li5lZmM0YzcxIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjcmVzcmMuaAorKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjcmVzcmMuaApAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNzdHJ1Y3QuaCBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNzdHJ1Y3QuaAppbmRleCBjZjczNDYxLi5kMTRiNTQ3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2Fjc3RydWN0LmgKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9hY3N0cnVjdC5oCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9hY3RhYmxlcy5oIGIvZHJpdmVycy9hY3BpL2FjcGljYS9hY3RhYmxlcy5oCmluZGV4IDFhZmU0NmUuLjFjMTI3YTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWN0YWJsZXMuaAorKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjdGFibGVzLmgKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjdXRpbHMuaCBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWN1dGlscy5oCmluZGV4IDQ4NmQzNDIuLmMyZjAzZTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWN1dGlscy5oCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWN1dGlscy5oCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9hbWxjb2RlLmggYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2FtbGNvZGUuaAppbmRleCA1OTA4Y2NlLi4zYTk1MDY4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2FtbGNvZGUuaAorKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2FtbGNvZGUuaApAQCAtNyw3ICs3LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvYW1scmVzcmMuaCBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYW1scmVzcmMuaAppbmRleCAzYTBiZWViLi5lZTBjZGQ2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2FtbHJlc3JjLmgKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9hbWxyZXNyYy5oCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9kc2FyZ3MuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHNhcmdzLmMKaW5kZXggNzIwYjFjZC4uM2U2OTg5NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9kc2FyZ3MuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2RzYXJncy5jCkBAIC02LDcgKzYsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9kc2NvbnRyb2wuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHNjb250cm9sLmMKaW5kZXggOGRhZjlkZS4uMzlkYTlkYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9kc2NvbnRyb2wuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2RzY29udHJvbC5jCkBAIC02LDcgKzYsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9kc2ZpZWxkLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2RzZmllbGQuYwppbmRleCBjNTc2NjYxLi40M2I0MGRlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2RzZmllbGQuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2RzZmllbGQuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHNpbml0LmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2RzaW5pdC5jCmluZGV4IGFlZTVlNDUuLmJiZTc0YmMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHNpbml0LmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9kc2luaXQuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHNtZXRob2QuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHNtZXRob2QuYwppbmRleCAzYzdmNzM3Li5kNzI1NjVhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2RzbWV0aG9kLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9kc21ldGhvZC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9kc210aGRhdC5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9kc210aGRhdC5jCmluZGV4IGI2NzUyMmQuLjJlNGM0MmIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHNtdGhkYXQuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2RzbXRoZGF0LmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9kc29iamVjdC5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9kc29iamVjdC5jCmluZGV4IGExZTdlNmIuLjhhN2IwN2IgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHNvYmplY3QuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2Rzb2JqZWN0LmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2Rzb3Bjb2RlLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2Rzb3Bjb2RlLmMKaW5kZXggNmMwNzU5Yy4uNzcyNDQxOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9kc29wY29kZS5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHNvcGNvZGUuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHN1dGlscy5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9kc3V0aWxzLmMKaW5kZXggOWY3NDc5NS4uZTVmZjg5YiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9kc3V0aWxzLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9kc3V0aWxzLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9kc3dleGVjLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2Rzd2V4ZWMuYwppbmRleCBmN2Y1MTA3Li5kZjU0ZDQ2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2Rzd2V4ZWMuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2Rzd2V4ZWMuYwpAQCAtNiw3ICs2LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHN3bG9hZC5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9kc3dsb2FkLmMKaW5kZXggMTU2MjNkYTIuLjg0Mzk0MmYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHN3bG9hZC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHN3bG9hZC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9kc3dsb2FkMi5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9kc3dsb2FkMi5jCmluZGV4IDJhYzI4ZDIuLmZjYWEzMGMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHN3bG9hZDIuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2Rzd2xvYWQyLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2Rzd3Njb3BlLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2Rzd3Njb3BlLmMKaW5kZXggOWQ2ZTJjMS4uNDNiM2VhNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9kc3dzY29wZS5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHN3c2NvcGUuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHN3c3RhdGUuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHN3c3RhdGUuYwppbmRleCAyNGY3ZDVlLi44OWFjMjAyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2Rzd3N0YXRlLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9kc3dzdGF0ZS5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9ldmV2ZW50LmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2ZXZlbnQuYwppbmRleCBjN2JmZmZmLi5iZjY4NzNmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2ZXZlbnQuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2ZXZlbnQuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZnbG9jay5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9ldmdsb2NrLmMKaW5kZXggMzM5M2E3My4uYjc4ZGM3YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9ldmdsb2NrLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9ldmdsb2NrLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2Z3BlLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2Z3BlLmMKaW5kZXggYWE3MDE1NC4uNWVkMDY0ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9ldmdwZS5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZncGUuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKQEAgLTExNCwxNyArMTE0LDYgQEAKIAogCUFDUElfRlVOQ1RJT05fVFJBQ0UoZXZfZW5hYmxlX2dwZSk7CiAKLQkvKgotCSAqIFdlIHdpbGwgb25seSBhbGxvdyBhIEdQRSB0byBiZSBlbmFibGVkIGlmIGl0IGhhcyBlaXRoZXIgYW4gYXNzb2NpYXRlZAotCSAqIG1ldGhvZCAoX0x4eC9fRXh4KSBvciBhIGhhbmRsZXIsIG9yIGlzIHVzaW5nIHRoZSBpbXBsaWNpdCBub3RpZnkKLQkgKiBmZWF0dXJlLiBPdGhlcndpc2UsIHRoZSBHUEUgd2lsbCBiZSBpbW1lZGlhdGVseSBkaXNhYmxlZCBieQotCSAqIGFjcGlfZXZfZ3BlX2Rpc3BhdGNoIHRoZSBmaXJzdCB0aW1lIGl0IGZpcmVzLgotCSAqLwotCWlmICgoZ3BlX2V2ZW50X2luZm8tPmZsYWdzICYgQUNQSV9HUEVfRElTUEFUQ0hfTUFTSykgPT0KLQkgICAgQUNQSV9HUEVfRElTUEFUQ0hfTk9ORSkgewotCQlyZXR1cm5fQUNQSV9TVEFUVVMoQUVfTk9fSEFORExFUik7Ci0JfQotCiAJLyogQ2xlYXIgdGhlIEdQRSAob2Ygc3RhbGUgZXZlbnRzKSAqLwogCiAJc3RhdHVzID0gYWNwaV9od19jbGVhcl9ncGUoZ3BlX2V2ZW50X2luZm8pOwpAQCAtMzM5LDcgKzMyOCwxMSBAQAogewogCWFjcGlfc3RhdHVzIHN0YXR1czsKIAlzdHJ1Y3QgYWNwaV9ncGVfYmxvY2tfaW5mbyAqZ3BlX2Jsb2NrOworCXN0cnVjdCBhY3BpX25hbWVzcGFjZV9ub2RlICpncGVfZGV2aWNlOwogCXN0cnVjdCBhY3BpX2dwZV9yZWdpc3Rlcl9pbmZvICpncGVfcmVnaXN0ZXJfaW5mbzsKKwlzdHJ1Y3QgYWNwaV9ncGVfZXZlbnRfaW5mbyAqZ3BlX2V2ZW50X2luZm87CisJdTMyIGdwZV9udW1iZXI7CisJc3RydWN0IGFjcGlfZ3BlX2hhbmRsZXJfaW5mbyAqZ3BlX2hhbmRsZXJfaW5mbzsKIAl1MzIgaW50X3N0YXR1cyA9IEFDUElfSU5URVJSVVBUX05PVF9IQU5ETEVEOwogCXU4IGVuYWJsZWRfc3RhdHVzX2J5dGU7CiAJdTMyIHN0YXR1c19yZWc7CkBAIC0zNjcsNiArMzYwLDggQEAKIAogCWdwZV9ibG9jayA9IGdwZV94cnVwdF9saXN0LT5ncGVfYmxvY2tfbGlzdF9oZWFkOwogCXdoaWxlIChncGVfYmxvY2spIHsKKwkJZ3BlX2RldmljZSA9IGdwZV9ibG9jay0+bm9kZTsKKwogCQkvKgogCQkgKiBSZWFkIGFsbCBvZiB0aGUgOC1iaXQgR1BFIHN0YXR1cyBhbmQgZW5hYmxlIHJlZ2lzdGVycyBpbiB0aGlzIEdQRQogCQkgKiBibG9jaywgc2F2aW5nIGFsbCBvZiB0aGVtLiBGaW5kIGFsbCBjdXJyZW50bHkgYWN0aXZlIEdQIGV2ZW50cy4KQEAgLTQ0MiwxNiArNDM3LDY4IEBACiAKIAkJCQkvKiBFeGFtaW5lIG9uZSBHUEUgYml0ICovCiAKKwkJCQlncGVfZXZlbnRfaW5mbyA9CisJCQkJICAgICZncGVfYmxvY2stPgorCQkJCSAgICBldmVudF9pbmZvWygoYWNwaV9zaXplKSBpICoKKwkJCQkJCUFDUElfR1BFX1JFR0lTVEVSX1dJRFRIKSArIGpdOworCQkJCWdwZV9udW1iZXIgPQorCQkJCSAgICBqICsgZ3BlX3JlZ2lzdGVyX2luZm8tPmJhc2VfZ3BlX251bWJlcjsKKwogCQkJCWlmIChlbmFibGVkX3N0YXR1c19ieXRlICYgKDEgPDwgaikpIHsKLQkJCQkJLyoKLQkJCQkJICogRm91bmQgYW4gYWN0aXZlIEdQRS4gRGlzcGF0Y2ggdGhlIGV2ZW50IHRvIGEgaGFuZGxlcgotCQkJCQkgKiBvciBtZXRob2QuCi0JCQkJCSAqLwotCQkJCQlpbnRfc3RhdHVzIHw9Ci0JCQkJCSAgICBhY3BpX2V2X2dwZV9kaXNwYXRjaChncGVfYmxvY2stPgotCQkJCQkJCQkgbm9kZSwKLQkJCQkJCQkJICZncGVfYmxvY2stPgotCQkJCQkJCQkgZXZlbnRfaW5mb1soKGFjcGlfc2l6ZSkgaSAqIEFDUElfR1BFX1JFR0lTVEVSX1dJRFRIKSArIGpdLCBqICsgZ3BlX3JlZ2lzdGVyX2luZm8tPmJhc2VfZ3BlX251bWJlcik7CisKKwkJCQkJLyogSW52b2tlIGdsb2JhbCBldmVudCBoYW5kbGVyIGlmIHByZXNlbnQgKi8KKworCQkJCQlhY3BpX2dwZV9jb3VudCsrOworCQkJCQlpZiAoYWNwaV9nYmxfZ2xvYmFsX2V2ZW50X2hhbmRsZXIpIHsKKwkJCQkJCWFjcGlfZ2JsX2dsb2JhbF9ldmVudF9oYW5kbGVyCisJCQkJCQkgICAgKEFDUElfRVZFTlRfVFlQRV9HUEUsCisJCQkJCQkgICAgIGdwZV9kZXZpY2UsIGdwZV9udW1iZXIsCisJCQkJCQkgICAgIGFjcGlfZ2JsX2dsb2JhbF9ldmVudF9oYW5kbGVyX2NvbnRleHQpOworCQkJCQl9CisKKwkJCQkJLyogRm91bmQgYW4gYWN0aXZlIEdQRSAqLworCisJCQkJCWlmIChBQ1BJX0dQRV9ESVNQQVRDSF9UWVBFCisJCQkJCSAgICAoZ3BlX2V2ZW50X2luZm8tPmZsYWdzKSA9PQorCQkJCQkgICAgQUNQSV9HUEVfRElTUEFUQ0hfUkFXX0hBTkRMRVIpIHsKKworCQkJCQkJLyogRGlzcGF0Y2ggdGhlIGV2ZW50IHRvIGEgcmF3IGhhbmRsZXIgKi8KKworCQkJCQkJZ3BlX2hhbmRsZXJfaW5mbyA9CisJCQkJCQkgICAgZ3BlX2V2ZW50X2luZm8tPmRpc3BhdGNoLgorCQkJCQkJICAgIGhhbmRsZXI7CisKKwkJCQkJCS8qCisJCQkJCQkgKiBUaGVyZSBpcyBubyBwcm90ZWN0aW9uIGFyb3VuZCB0aGUgbmFtZXNwYWNlIG5vZGUKKwkJCQkJCSAqIGFuZCB0aGUgR1BFIGhhbmRsZXIgdG8gZW5zdXJlIGEgc2FmZSBkZXN0cnVjdGlvbgorCQkJCQkJICogYmVjYXVzZToKKwkJCQkJCSAqIDEuIFRoZSBuYW1lc3BhY2Ugbm9kZSBpcyBleHBlY3RlZCB0byBhbHdheXMKKwkJCQkJCSAqICAgIGV4aXN0IGFmdGVyIGxvYWRpbmcgYSB0YWJsZS4KKwkJCQkJCSAqIDIuIFRoZSBHUEUgaGFuZGxlciBpcyBleHBlY3RlZCB0byBiZSBmbHVzaGVkIGJ5CisJCQkJCQkgKiAgICBhY3BpX29zX3dhaXRfZXZlbnRzX2NvbXBsZXRlKCkgYmVmb3JlIHRoZQorCQkJCQkJICogICAgZGVzdHJ1Y3Rpb24uCisJCQkJCQkgKi8KKwkJCQkJCWFjcGlfb3NfcmVsZWFzZV9sb2NrCisJCQkJCQkgICAgKGFjcGlfZ2JsX2dwZV9sb2NrLCBmbGFncyk7CisJCQkJCQlpbnRfc3RhdHVzIHw9CisJCQkJCQkgICAgZ3BlX2hhbmRsZXJfaW5mby0+CisJCQkJCQkgICAgYWRkcmVzcyhncGVfZGV2aWNlLAorCQkJCQkJCSAgICBncGVfbnVtYmVyLAorCQkJCQkJCSAgICBncGVfaGFuZGxlcl9pbmZvLT4KKwkJCQkJCQkgICAgY29udGV4dCk7CisJCQkJCQlmbGFncyA9CisJCQkJCQkgICAgYWNwaV9vc19hY3F1aXJlX2xvY2sKKwkJCQkJCSAgICAoYWNwaV9nYmxfZ3BlX2xvY2spOworCQkJCQl9IGVsc2UgeworCQkJCQkJLyoKKwkJCQkJCSAqIERpc3BhdGNoIHRoZSBldmVudCB0byBhIHN0YW5kYXJkIGhhbmRsZXIgb3IKKwkJCQkJCSAqIG1ldGhvZC4KKwkJCQkJCSAqLworCQkJCQkJaW50X3N0YXR1cyB8PQorCQkJCQkJICAgIGFjcGlfZXZfZ3BlX2Rpc3BhdGNoCisJCQkJCQkgICAgKGdwZV9kZXZpY2UsIGdwZV9ldmVudF9pbmZvLAorCQkJCQkJICAgICBncGVfbnVtYmVyKTsKKwkJCQkJfQogCQkJCX0KIAkJCX0KIAkJfQpAQCAtNDg0LDUyICs1MzEsMTUgQEAKIHN0YXRpYyB2b2lkIEFDUElfU1lTVEVNX1hGQUNFIGFjcGlfZXZfYXN5bmNoX2V4ZWN1dGVfZ3BlX21ldGhvZCh2b2lkICpjb250ZXh0KQogewogCXN0cnVjdCBhY3BpX2dwZV9ldmVudF9pbmZvICpncGVfZXZlbnRfaW5mbyA9IGNvbnRleHQ7Ci0JYWNwaV9zdGF0dXMgc3RhdHVzOwotCXN0cnVjdCBhY3BpX2dwZV9ldmVudF9pbmZvICpsb2NhbF9ncGVfZXZlbnRfaW5mbzsKKwlhY3BpX3N0YXR1cyBzdGF0dXMgPSBBRV9PSzsKIAlzdHJ1Y3QgYWNwaV9ldmFsdWF0ZV9pbmZvICppbmZvOwogCXN0cnVjdCBhY3BpX2dwZV9ub3RpZnlfaW5mbyAqbm90aWZ5OwogCiAJQUNQSV9GVU5DVElPTl9UUkFDRShldl9hc3luY2hfZXhlY3V0ZV9ncGVfbWV0aG9kKTsKIAotCS8qIEFsbG9jYXRlIGEgbG9jYWwgR1BFIGJsb2NrICovCi0KLQlsb2NhbF9ncGVfZXZlbnRfaW5mbyA9Ci0JICAgIEFDUElfQUxMT0NBVEVfWkVST0VEKHNpemVvZihzdHJ1Y3QgYWNwaV9ncGVfZXZlbnRfaW5mbykpOwotCWlmICghbG9jYWxfZ3BlX2V2ZW50X2luZm8pIHsKLQkJQUNQSV9FWENFUFRJT04oKEFFX0lORk8sIEFFX05PX01FTU9SWSwgIndoaWxlIGhhbmRsaW5nIGEgR1BFIikpOwotCQlyZXR1cm5fVk9JRDsKLQl9Ci0KLQlzdGF0dXMgPSBhY3BpX3V0X2FjcXVpcmVfbXV0ZXgoQUNQSV9NVFhfRVZFTlRTKTsKLQlpZiAoQUNQSV9GQUlMVVJFKHN0YXR1cykpIHsKLQkJQUNQSV9GUkVFKGxvY2FsX2dwZV9ldmVudF9pbmZvKTsKLQkJcmV0dXJuX1ZPSUQ7Ci0JfQotCi0JLyogTXVzdCByZXZhbGlkYXRlIHRoZSBncGVfbnVtYmVyL2dwZV9ibG9jayAqLwotCi0JaWYgKCFhY3BpX2V2X3ZhbGlkX2dwZV9ldmVudChncGVfZXZlbnRfaW5mbykpIHsKLQkJc3RhdHVzID0gYWNwaV91dF9yZWxlYXNlX211dGV4KEFDUElfTVRYX0VWRU5UUyk7Ci0JCUFDUElfRlJFRShsb2NhbF9ncGVfZXZlbnRfaW5mbyk7Ci0JCXJldHVybl9WT0lEOwotCX0KLQotCS8qCi0JICogVGFrZSBhIHNuYXBzaG90IG9mIHRoZSBHUEUgaW5mbyBmb3IgdGhpcyBsZXZlbCAtIHdlIGNvcHkgdGhlIGluZm8gdG8KLQkgKiBwcmV2ZW50IGEgcmFjZSBjb25kaXRpb24gd2l0aCByZW1vdmVfaGFuZGxlci9yZW1vdmVfYmxvY2suCi0JICovCi0JQUNQSV9NRU1DUFkobG9jYWxfZ3BlX2V2ZW50X2luZm8sIGdwZV9ldmVudF9pbmZvLAotCQkgICAgc2l6ZW9mKHN0cnVjdCBhY3BpX2dwZV9ldmVudF9pbmZvKSk7Ci0KLQlzdGF0dXMgPSBhY3BpX3V0X3JlbGVhc2VfbXV0ZXgoQUNQSV9NVFhfRVZFTlRTKTsKLQlpZiAoQUNQSV9GQUlMVVJFKHN0YXR1cykpIHsKLQkJQUNQSV9GUkVFKGxvY2FsX2dwZV9ldmVudF9pbmZvKTsKLQkJcmV0dXJuX1ZPSUQ7Ci0JfQotCiAJLyogRG8gdGhlIGNvcnJlY3QgZGlzcGF0Y2ggLSBub3JtYWwgbWV0aG9kIG9yIGltcGxpY2l0IG5vdGlmeSAqLwogCi0Jc3dpdGNoIChsb2NhbF9ncGVfZXZlbnRfaW5mby0+ZmxhZ3MgJiBBQ1BJX0dQRV9ESVNQQVRDSF9NQVNLKSB7CisJc3dpdGNoIChBQ1BJX0dQRV9ESVNQQVRDSF9UWVBFKGdwZV9ldmVudF9pbmZvLT5mbGFncykpIHsKIAljYXNlIEFDUElfR1BFX0RJU1BBVENIX05PVElGWToKIAkJLyoKIAkJICogSW1wbGljaXQgbm90aWZ5LgpAQCAtNTQyLDcgKzU1Miw3IEBACiAJCSAqIEp1bmUgMjAxMjogRXhwYW5kIGltcGxpY2l0IG5vdGlmeSBtZWNoYW5pc20gdG8gc3VwcG9ydAogCQkgKiBub3RpZmllcyBvbiBtdWx0aXBsZSBkZXZpY2Ugb2JqZWN0cy4KIAkJICovCi0JCW5vdGlmeSA9IGxvY2FsX2dwZV9ldmVudF9pbmZvLT5kaXNwYXRjaC5ub3RpZnlfbGlzdDsKKwkJbm90aWZ5ID0gZ3BlX2V2ZW50X2luZm8tPmRpc3BhdGNoLm5vdGlmeV9saXN0OwogCQl3aGlsZSAoQUNQSV9TVUNDRVNTKHN0YXR1cykgJiYgbm90aWZ5KSB7CiAJCQlzdGF0dXMgPQogCQkJICAgIGFjcGlfZXZfcXVldWVfbm90aWZ5X3JlcXVlc3Qobm90aWZ5LT5kZXZpY2Vfbm9kZSwKQEAgLTU2Niw3ICs1NzYsNyBAQAogCQkJICogX0x4eC9fRXh4IGNvbnRyb2wgbWV0aG9kIHRoYXQgY29ycmVzcG9uZHMgdG8gdGhpcyBHUEUKIAkJCSAqLwogCQkJaW5mby0+cHJlZml4X25vZGUgPQotCQkJICAgIGxvY2FsX2dwZV9ldmVudF9pbmZvLT5kaXNwYXRjaC5tZXRob2Rfbm9kZTsKKwkJCSAgICBncGVfZXZlbnRfaW5mby0+ZGlzcGF0Y2gubWV0aG9kX25vZGU7CiAJCQlpbmZvLT5mbGFncyA9IEFDUElfSUdOT1JFX1JFVFVSTl9WQUxVRTsKIAogCQkJc3RhdHVzID0gYWNwaV9uc19ldmFsdWF0ZShpbmZvKTsKQEAgLTU3NiwyNSArNTg2LDI3IEBACiAJCWlmIChBQ1BJX0ZBSUxVUkUoc3RhdHVzKSkgewogCQkJQUNQSV9FWENFUFRJT04oKEFFX0lORk8sIHN0YXR1cywKIAkJCQkJIndoaWxlIGV2YWx1YXRpbmcgR1BFIG1ldGhvZCBbJTQuNHNdIiwKLQkJCQkJYWNwaV91dF9nZXRfbm9kZV9uYW1lCi0JCQkJCShsb2NhbF9ncGVfZXZlbnRfaW5mby0+ZGlzcGF0Y2guCi0JCQkJCSBtZXRob2Rfbm9kZSkpKTsKKwkJCQkJYWNwaV91dF9nZXRfbm9kZV9uYW1lKGdwZV9ldmVudF9pbmZvLT4KKwkJCQkJCQkgICAgICBkaXNwYXRjaC4KKwkJCQkJCQkgICAgICBtZXRob2Rfbm9kZSkpKTsKIAkJfQogCQlicmVhazsKIAogCWRlZmF1bHQ6CiAKLQkJcmV0dXJuX1ZPSUQ7CS8qIFNob3VsZCBuZXZlciBoYXBwZW4gKi8KKwkJZ290byBlcnJvcl9leGl0OwkvKiBTaG91bGQgbmV2ZXIgaGFwcGVuICovCiAJfQogCiAJLyogRGVmZXIgZW5hYmxpbmcgb2YgR1BFIHVudGlsIGFsbCBub3RpZnkgaGFuZGxlcnMgYXJlIGRvbmUgKi8KIAogCXN0YXR1cyA9IGFjcGlfb3NfZXhlY3V0ZShPU0xfTk9USUZZX0hBTkRMRVIsCi0JCQkJIGFjcGlfZXZfYXN5bmNoX2VuYWJsZV9ncGUsCi0JCQkJIGxvY2FsX2dwZV9ldmVudF9pbmZvKTsKLQlpZiAoQUNQSV9GQUlMVVJFKHN0YXR1cykpIHsKLQkJQUNQSV9GUkVFKGxvY2FsX2dwZV9ldmVudF9pbmZvKTsKKwkJCQkgYWNwaV9ldl9hc3luY2hfZW5hYmxlX2dwZSwgZ3BlX2V2ZW50X2luZm8pOworCWlmIChBQ1BJX1NVQ0NFU1Moc3RhdHVzKSkgeworCQlyZXR1cm5fVk9JRDsKIAl9CisKK2Vycm9yX2V4aXQ6CisJYWNwaV9ldl9hc3luY2hfZW5hYmxlX2dwZShncGVfZXZlbnRfaW5mbyk7CiAJcmV0dXJuX1ZPSUQ7CiB9CiAKQEAgLTYyMiw3ICs2MzQsNiBAQAogCSh2b2lkKWFjcGlfZXZfZmluaXNoX2dwZShncGVfZXZlbnRfaW5mbyk7CiAJYWNwaV9vc19yZWxlYXNlX2xvY2soYWNwaV9nYmxfZ3BlX2xvY2ssIGZsYWdzKTsKIAotCUFDUElfRlJFRShncGVfZXZlbnRfaW5mbyk7CiAJcmV0dXJuOwogfQogCkBAIC02OTIsMTUgKzcwMyw2IEBACiAKIAlBQ1BJX0ZVTkNUSU9OX1RSQUNFKGV2X2dwZV9kaXNwYXRjaCk7CiAKLQkvKiBJbnZva2UgZ2xvYmFsIGV2ZW50IGhhbmRsZXIgaWYgcHJlc2VudCAqLwotCi0JYWNwaV9ncGVfY291bnQrKzsKLQlpZiAoYWNwaV9nYmxfZ2xvYmFsX2V2ZW50X2hhbmRsZXIpIHsKLQkJYWNwaV9nYmxfZ2xvYmFsX2V2ZW50X2hhbmRsZXIoQUNQSV9FVkVOVF9UWVBFX0dQRSwgZ3BlX2RldmljZSwKLQkJCQkJICAgICAgZ3BlX251bWJlciwKLQkJCQkJICAgICAgYWNwaV9nYmxfZ2xvYmFsX2V2ZW50X2hhbmRsZXJfY29udGV4dCk7Ci0JfQotCiAJLyoKIAkgKiBBbHdheXMgZGlzYWJsZSB0aGUgR1BFIHNvIHRoYXQgaXQgZG9lcyBub3Qga2VlcCBmaXJpbmcgYmVmb3JlCiAJICogYW55IGFzeW5jaHJvbm91cyBhY3Rpdml0eSBjb21wbGV0ZXMgKGVpdGhlciBmcm9tIHRoZSBleGVjdXRpb24KQEAgLTc0MSw3ICs3NDMsNyBAQAogCSAqIElmIHRoZXJlIGlzIG5laXRoZXIgYSBoYW5kbGVyIG5vciBhIG1ldGhvZCwgbGVhdmUgdGhlIEdQRQogCSAqIGRpc2FibGVkLgogCSAqLwotCXN3aXRjaCAoZ3BlX2V2ZW50X2luZm8tPmZsYWdzICYgQUNQSV9HUEVfRElTUEFUQ0hfTUFTSykgeworCXN3aXRjaCAoQUNQSV9HUEVfRElTUEFUQ0hfVFlQRShncGVfZXZlbnRfaW5mby0+ZmxhZ3MpKSB7CiAJY2FzZSBBQ1BJX0dQRV9ESVNQQVRDSF9IQU5ETEVSOgogCiAJCS8qIEludm9rZSB0aGUgaW5zdGFsbGVkIGhhbmRsZXIgKGF0IGludGVycnVwdCBsZXZlbCkgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZncGVibGsuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZncGVibGsuYwppbmRleCBkODY2OTllLi5lMGYyNGM1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2Z3BlYmxrLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9ldmdwZWJsay5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApAQCAtNDc0LDEwICs0NzQsMTIgQEAKIAkJCSAqIElnbm9yZSBHUEVzIHRoYXQgaGF2ZSBubyBjb3JyZXNwb25kaW5nIF9MeHgvX0V4eCBtZXRob2QKIAkJCSAqIGFuZCBHUEVzIHRoYXQgYXJlIHVzZWQgdG8gd2FrZSB0aGUgc3lzdGVtCiAJCQkgKi8KLQkJCWlmICgoKGdwZV9ldmVudF9pbmZvLT5mbGFncyAmIEFDUElfR1BFX0RJU1BBVENIX01BU0spID09CisJCQlpZiAoKEFDUElfR1BFX0RJU1BBVENIX1RZUEUoZ3BlX2V2ZW50X2luZm8tPmZsYWdzKSA9PQogCQkJICAgICBBQ1BJX0dQRV9ESVNQQVRDSF9OT05FKQotCQkJICAgIHx8ICgoZ3BlX2V2ZW50X2luZm8tPmZsYWdzICYgQUNQSV9HUEVfRElTUEFUQ0hfTUFTSykKLQkJCQk9PSBBQ1BJX0dQRV9ESVNQQVRDSF9IQU5ETEVSKQorCQkJICAgIHx8IChBQ1BJX0dQRV9ESVNQQVRDSF9UWVBFKGdwZV9ldmVudF9pbmZvLT5mbGFncykgPT0KKwkJCQlBQ1BJX0dQRV9ESVNQQVRDSF9IQU5ETEVSKQorCQkJICAgIHx8IChBQ1BJX0dQRV9ESVNQQVRDSF9UWVBFKGdwZV9ldmVudF9pbmZvLT5mbGFncykgPT0KKwkJCQlBQ1BJX0dQRV9ESVNQQVRDSF9SQVdfSEFORExFUikKIAkJCSAgICB8fCAoZ3BlX2V2ZW50X2luZm8tPmZsYWdzICYgQUNQSV9HUEVfQ0FOX1dBS0UpKSB7CiAJCQkJY29udGludWU7CiAJCQl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2Z3BlaW5pdC5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9ldmdwZWluaXQuYwppbmRleCA3YmU5MjgzLi44ODQwMjk2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2Z3BlaW5pdC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZncGVpbml0LmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CkBAIC00MDEsMTUgKzQwMSwxNyBAQAogCQlyZXR1cm5fQUNQSV9TVEFUVVMoQUVfT0spOwogCX0KIAotCWlmICgoZ3BlX2V2ZW50X2luZm8tPmZsYWdzICYgQUNQSV9HUEVfRElTUEFUQ0hfTUFTSykgPT0KLQkgICAgQUNQSV9HUEVfRElTUEFUQ0hfSEFORExFUikgeworCWlmICgoQUNQSV9HUEVfRElTUEFUQ0hfVFlQRShncGVfZXZlbnRfaW5mby0+ZmxhZ3MpID09CisJICAgICBBQ1BJX0dQRV9ESVNQQVRDSF9IQU5ETEVSKSB8fAorCSAgICAoQUNQSV9HUEVfRElTUEFUQ0hfVFlQRShncGVfZXZlbnRfaW5mby0+ZmxhZ3MpID09CisJICAgICBBQ1BJX0dQRV9ESVNQQVRDSF9SQVdfSEFORExFUikpIHsKIAogCQkvKiBJZiB0aGVyZSBpcyBhbHJlYWR5IGEgaGFuZGxlciwgaWdub3JlIHRoaXMgR1BFIG1ldGhvZCAqLwogCiAJCXJldHVybl9BQ1BJX1NUQVRVUyhBRV9PSyk7CiAJfQogCi0JaWYgKChncGVfZXZlbnRfaW5mby0+ZmxhZ3MgJiBBQ1BJX0dQRV9ESVNQQVRDSF9NQVNLKSA9PQorCWlmIChBQ1BJX0dQRV9ESVNQQVRDSF9UWVBFKGdwZV9ldmVudF9pbmZvLT5mbGFncykgPT0KIAkgICAgQUNQSV9HUEVfRElTUEFUQ0hfTUVUSE9EKSB7CiAJCS8qCiAJCSAqIElmIHRoZXJlIGlzIGFscmVhZHkgYSBtZXRob2QsIGlnbm9yZSB0aGlzIG1ldGhvZC4gQnV0IGNoZWNrCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2Z3BldXRpbC5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9ldmdwZXV0aWwuYwppbmRleCAxN2U0YmJmLi4zYTk1OGYzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2Z3BldXRpbC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZncGV1dGlsLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CkBAIC0xMDgsNTMgKzEwOCw2IEBACiAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAgKgotICogRlVOQ1RJT046ICAgIGFjcGlfZXZfdmFsaWRfZ3BlX2V2ZW50Ci0gKgotICogUEFSQU1FVEVSUzogIGdwZV9ldmVudF9pbmZvICAgICAgICAgICAgICAtIEluZm8gZm9yIHRoaXMgR1BFCi0gKgotICogUkVUVVJOOiAgICAgIFRSVUUgaWYgdGhlIGdwZV9ldmVudCBpcyB2YWxpZAotICoKLSAqIERFU0NSSVBUSU9OOiBWYWxpZGF0ZSBhIEdQRSBldmVudC4gRE8gTk9UIENBTEwgRlJPTSBJTlRFUlJVUFQgTEVWRUwuCi0gKiAgICAgICAgICAgICAgU2hvdWxkIGJlIGNhbGxlZCBvbmx5IHdoZW4gdGhlIEdQRSBsaXN0cyBhcmUgc2VtYXBob3JlIGxvY2tlZAotICogICAgICAgICAgICAgIGFuZCBub3Qgc3ViamVjdCB0byBjaGFuZ2UuCi0gKgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLQotdTggYWNwaV9ldl92YWxpZF9ncGVfZXZlbnQoc3RydWN0IGFjcGlfZ3BlX2V2ZW50X2luZm8gKmdwZV9ldmVudF9pbmZvKQotewotCXN0cnVjdCBhY3BpX2dwZV94cnVwdF9pbmZvICpncGVfeHJ1cHRfYmxvY2s7Ci0Jc3RydWN0IGFjcGlfZ3BlX2Jsb2NrX2luZm8gKmdwZV9ibG9jazsKLQotCUFDUElfRlVOQ1RJT05fRU5UUlkoKTsKLQotCS8qIE5vIG5lZWQgZm9yIHNwaW4gbG9jayBzaW5jZSB3ZSBhcmUgbm90IGNoYW5naW5nIGFueSBsaXN0IGVsZW1lbnRzICovCi0KLQkvKiBXYWxrIHRoZSBHUEUgaW50ZXJydXB0IGxldmVscyAqLwotCi0JZ3BlX3hydXB0X2Jsb2NrID0gYWNwaV9nYmxfZ3BlX3hydXB0X2xpc3RfaGVhZDsKLQl3aGlsZSAoZ3BlX3hydXB0X2Jsb2NrKSB7Ci0JCWdwZV9ibG9jayA9IGdwZV94cnVwdF9ibG9jay0+Z3BlX2Jsb2NrX2xpc3RfaGVhZDsKLQotCQkvKiBXYWxrIHRoZSBHUEUgYmxvY2tzIG9uIHRoaXMgaW50ZXJydXB0IGxldmVsICovCi0KLQkJd2hpbGUgKGdwZV9ibG9jaykgewotCQkJaWYgKCgmZ3BlX2Jsb2NrLT5ldmVudF9pbmZvWzBdIDw9IGdwZV9ldmVudF9pbmZvKSAmJgotCQkJICAgICgmZ3BlX2Jsb2NrLT5ldmVudF9pbmZvW2dwZV9ibG9jay0+Z3BlX2NvdW50XSA+Ci0JCQkgICAgIGdwZV9ldmVudF9pbmZvKSkgewotCQkJCXJldHVybiAoVFJVRSk7Ci0JCQl9Ci0KLQkJCWdwZV9ibG9jayA9IGdwZV9ibG9jay0+bmV4dDsKLQkJfQotCi0JCWdwZV94cnVwdF9ibG9jayA9IGdwZV94cnVwdF9ibG9jay0+bmV4dDsKLQl9Ci0KLQlyZXR1cm4gKEZBTFNFKTsKLX0KLQotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqCiAgKiBGVU5DVElPTjogICAgYWNwaV9ldl9nZXRfZ3BlX2RldmljZQogICoKICAqIFBBUkFNRVRFUlM6ICBHUEVfV0FMS19DQUxMQkFDSwpAQCAtMzcxLDggKzMyNCwxMCBAQAogCQkJCQkJCQkgQUNQSV9HUEVfUkVHSVNURVJfV0lEVEgpCiAJCQkJCQkJCSsgal07CiAKLQkJCWlmICgoZ3BlX2V2ZW50X2luZm8tPmZsYWdzICYgQUNQSV9HUEVfRElTUEFUQ0hfTUFTSykgPT0KLQkJCSAgICBBQ1BJX0dQRV9ESVNQQVRDSF9IQU5ETEVSKSB7CisJCQlpZiAoKEFDUElfR1BFX0RJU1BBVENIX1RZUEUoZ3BlX2V2ZW50X2luZm8tPmZsYWdzKSA9PQorCQkJICAgICBBQ1BJX0dQRV9ESVNQQVRDSF9IQU5ETEVSKSB8fAorCQkJICAgIChBQ1BJX0dQRV9ESVNQQVRDSF9UWVBFKGdwZV9ldmVudF9pbmZvLT5mbGFncykgPT0KKwkJCSAgICAgQUNQSV9HUEVfRElTUEFUQ0hfUkFXX0hBTkRMRVIpKSB7CiAKIAkJCQkvKiBEZWxldGUgYW4gaW5zdGFsbGVkIGhhbmRsZXIgYmxvY2sgKi8KIApAQCAtMzgwLDEwICszMzUsOCBAQAogCQkJCWdwZV9ldmVudF9pbmZvLT5kaXNwYXRjaC5oYW5kbGVyID0gTlVMTDsKIAkJCQlncGVfZXZlbnRfaW5mby0+ZmxhZ3MgJj0KIAkJCQkgICAgfkFDUElfR1BFX0RJU1BBVENIX01BU0s7Ci0JCQl9IGVsc2UKLQkJCSAgICBpZiAoKGdwZV9ldmVudF9pbmZvLT4KLQkJCQkgZmxhZ3MgJiBBQ1BJX0dQRV9ESVNQQVRDSF9NQVNLKSA9PQotCQkJCUFDUElfR1BFX0RJU1BBVENIX05PVElGWSkgeworCQkJfSBlbHNlIGlmIChBQ1BJX0dQRV9ESVNQQVRDSF9UWVBFKGdwZV9ldmVudF9pbmZvLT5mbGFncykKKwkJCQkgICA9PSBBQ1BJX0dQRV9ESVNQQVRDSF9OT1RJRlkpIHsKIAogCQkJCS8qIERlbGV0ZSB0aGUgaW1wbGljaXQgbm90aWZpY2F0aW9uIGRldmljZSBsaXN0ICovCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZoYW5kbGVyLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2aGFuZGxlci5jCmluZGV4IDc4YWMyOTMuLjc0ZTg1OTVmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2aGFuZGxlci5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZoYW5kbGVyLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2bWlzYy5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9ldm1pc2MuYwppbmRleCAyNGVhMzQyLi5mN2M5ZGZlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2bWlzYy5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZtaXNjLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2cmVnaW9uLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2cmVnaW9uLmMKaW5kZXggOGViODU3NS4uOWFiYWNlMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9ldnJlZ2lvbi5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZyZWdpb24uYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZyZ25pbmkuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZyZ25pbmkuYwppbmRleCAxYjE0OGE0Li5kYTMyMzM5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2cmduaW5pLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9ldnJnbmluaS5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9ldnNjaS5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9ldnNjaS5jCmluZGV4IDI5NjMwZTMuLjAzNjY3MDMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZzY2kuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2c2NpLmMKQEAgLTYsNyArNiw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9ldnhmYWNlLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2eGZhY2UuYwppbmRleCA1NWE1OGYzLi44MWYyZDllIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2eGZhY2UuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2eGZhY2UuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKQEAgLTUxLDYgKzUxLDE2IEBACiAKICNkZWZpbmUgX0NPTVBPTkVOVCAgICAgICAgICBBQ1BJX0VWRU5UUwogQUNQSV9NT0RVTEVfTkFNRSgiZXZ4ZmFjZSIpCisjaWYgKCFBQ1BJX1JFRFVDRURfSEFSRFdBUkUpCisvKiBMb2NhbCBwcm90b3R5cGVzICovCitzdGF0aWMgYWNwaV9zdGF0dXMKK2FjcGlfZXZfaW5zdGFsbF9ncGVfaGFuZGxlcihhY3BpX2hhbmRsZSBncGVfZGV2aWNlLAorCQkJICAgIHUzMiBncGVfbnVtYmVyLAorCQkJICAgIHUzMiB0eXBlLAorCQkJICAgIHU4IGlzX3Jhd19oYW5kbGVyLAorCQkJICAgIGFjcGlfZ3BlX2hhbmRsZXIgYWRkcmVzcywgdm9pZCAqY29udGV4dCk7CisKKyNlbmRpZgogCiAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCkBAIC03Niw2ICs4Niw3IEBACiAgKiAgICAgICAgICAgICAgaGFuZGxlcnMuCiAgKgogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKwogYWNwaV9zdGF0dXMKIGFjcGlfaW5zdGFsbF9ub3RpZnlfaGFuZGxlcihhY3BpX2hhbmRsZSBkZXZpY2UsCiAJCQkgICAgdTMyIGhhbmRsZXJfdHlwZSwKQEAgLTcxNywzMiArNzI4LDM3IEBACiAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAgKgotICogRlVOQ1RJT046ICAgIGFjcGlfaW5zdGFsbF9ncGVfaGFuZGxlcgorICogRlVOQ1RJT046ICAgIGFjcGlfZXZfaW5zdGFsbF9ncGVfaGFuZGxlcgogICoKICAqIFBBUkFNRVRFUlM6ICBncGVfZGV2aWNlICAgICAgLSBOYW1lc3BhY2Ugbm9kZSBmb3IgdGhlIEdQRSAoTlVMTCBmb3IgRkFEVAogICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGRlZmluZWQgR1BFcykKICAqICAgICAgICAgICAgICBncGVfbnVtYmVyICAgICAgLSBUaGUgR1BFIG51bWJlciB3aXRoaW4gdGhlIEdQRSBibG9jawogICogICAgICAgICAgICAgIHR5cGUgICAgICAgICAgICAtIFdoZXRoZXIgdGhpcyBHUEUgc2hvdWxkIGJlIHRyZWF0ZWQgYXMgYW4KICAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBlZGdlLSBvciBsZXZlbC10cmlnZ2VyZWQgaW50ZXJydXB0LgorICogICAgICAgICAgICAgIGlzX3Jhd19oYW5kbGVyICAtIFdoZXRoZXIgdGhpcyBHUEUgc2hvdWxkIGJlIGhhbmRsZWQgdXNpbmcKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0aGUgc3BlY2lhbCBHUEUgaGFuZGxlciBtb2RlLgogICogICAgICAgICAgICAgIGFkZHJlc3MgICAgICAgICAtIEFkZHJlc3Mgb2YgdGhlIGhhbmRsZXIKICAqICAgICAgICAgICAgICBjb250ZXh0ICAgICAgICAgLSBWYWx1ZSBwYXNzZWQgdG8gdGhlIGhhbmRsZXIgb24gZWFjaCBHUEUKICAqCiAgKiBSRVRVUk46ICAgICAgU3RhdHVzCiAgKgotICogREVTQ1JJUFRJT046IEluc3RhbGwgYSBoYW5kbGVyIGZvciBhIEdlbmVyYWwgUHVycG9zZSBFdmVudC4KKyAqIERFU0NSSVBUSU9OOiBJbnRlcm5hbCBmdW5jdGlvbiB0byBpbnN0YWxsIGEgaGFuZGxlciBmb3IgYSBHZW5lcmFsIFB1cnBvc2UKKyAqICAgICAgICAgICAgICBFdmVudC4KICAqCiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotYWNwaV9zdGF0dXMKLWFjcGlfaW5zdGFsbF9ncGVfaGFuZGxlcihhY3BpX2hhbmRsZSBncGVfZGV2aWNlLAotCQkJIHUzMiBncGVfbnVtYmVyLAotCQkJIHUzMiB0eXBlLCBhY3BpX2dwZV9oYW5kbGVyIGFkZHJlc3MsIHZvaWQgKmNvbnRleHQpCitzdGF0aWMgYWNwaV9zdGF0dXMKK2FjcGlfZXZfaW5zdGFsbF9ncGVfaGFuZGxlcihhY3BpX2hhbmRsZSBncGVfZGV2aWNlLAorCQkJICAgIHUzMiBncGVfbnVtYmVyLAorCQkJICAgIHUzMiB0eXBlLAorCQkJICAgIHU4IGlzX3Jhd19oYW5kbGVyLAorCQkJICAgIGFjcGlfZ3BlX2hhbmRsZXIgYWRkcmVzcywgdm9pZCAqY29udGV4dCkKIHsKIAlzdHJ1Y3QgYWNwaV9ncGVfZXZlbnRfaW5mbyAqZ3BlX2V2ZW50X2luZm87CiAJc3RydWN0IGFjcGlfZ3BlX2hhbmRsZXJfaW5mbyAqaGFuZGxlcjsKIAlhY3BpX3N0YXR1cyBzdGF0dXM7CiAJYWNwaV9jcHVfZmxhZ3MgZmxhZ3M7CiAKLQlBQ1BJX0ZVTkNUSU9OX1RSQUNFKGFjcGlfaW5zdGFsbF9ncGVfaGFuZGxlcik7CisJQUNQSV9GVU5DVElPTl9UUkFDRShldl9pbnN0YWxsX2dwZV9oYW5kbGVyKTsKIAogCS8qIFBhcmFtZXRlciB2YWxpZGF0aW9uICovCiAKQEAgLTc3NSw4ICs3OTEsMTAgQEAKIAogCS8qIE1ha2Ugc3VyZSB0aGF0IHRoZXJlIGlzbid0IGEgaGFuZGxlciB0aGVyZSBhbHJlYWR5ICovCiAKLQlpZiAoKGdwZV9ldmVudF9pbmZvLT5mbGFncyAmIEFDUElfR1BFX0RJU1BBVENIX01BU0spID09Ci0JICAgIEFDUElfR1BFX0RJU1BBVENIX0hBTkRMRVIpIHsKKwlpZiAoKEFDUElfR1BFX0RJU1BBVENIX1RZUEUoZ3BlX2V2ZW50X2luZm8tPmZsYWdzKSA9PQorCSAgICAgQUNQSV9HUEVfRElTUEFUQ0hfSEFORExFUikgfHwKKwkgICAgKEFDUElfR1BFX0RJU1BBVENIX1RZUEUoZ3BlX2V2ZW50X2luZm8tPmZsYWdzKSA9PQorCSAgICAgQUNQSV9HUEVfRElTUEFUQ0hfUkFXX0hBTkRMRVIpKSB7CiAJCXN0YXR1cyA9IEFFX0FMUkVBRFlfRVhJU1RTOwogCQlnb3RvIGZyZWVfYW5kX2V4aXQ7CiAJfQpAQCAtNzkzLDkgKzgxMSwxMCBAQAogCSAqIGF1dG9tYXRpY2FsbHkgZHVyaW5nIGluaXRpYWxpemF0aW9uLCBpbiB3aGljaCBjYXNlIGl0IGhhcyB0byBiZQogCSAqIGRpc2FibGVkIG5vdyB0byBhdm9pZCBzcHVyaW91cyBleGVjdXRpb24gb2YgdGhlIGhhbmRsZXIuCiAJICovCi0JaWYgKCgoaGFuZGxlci0+b3JpZ2luYWxfZmxhZ3MgJiBBQ1BJX0dQRV9ESVNQQVRDSF9NRVRIT0QpIHx8Ci0JICAgICAoaGFuZGxlci0+b3JpZ2luYWxfZmxhZ3MgJiBBQ1BJX0dQRV9ESVNQQVRDSF9OT1RJRlkpKSAmJgotCSAgICBncGVfZXZlbnRfaW5mby0+cnVudGltZV9jb3VudCkgeworCWlmICgoKEFDUElfR1BFX0RJU1BBVENIX1RZUEUoaGFuZGxlci0+b3JpZ2luYWxfZmxhZ3MpID09CisJICAgICAgQUNQSV9HUEVfRElTUEFUQ0hfTUVUSE9EKSB8fAorCSAgICAgKEFDUElfR1BFX0RJU1BBVENIX1RZUEUoaGFuZGxlci0+b3JpZ2luYWxfZmxhZ3MpID09CisJICAgICAgQUNQSV9HUEVfRElTUEFUQ0hfTk9USUZZKSkgJiYgZ3BlX2V2ZW50X2luZm8tPnJ1bnRpbWVfY291bnQpIHsKIAkJaGFuZGxlci0+b3JpZ2luYWxseV9lbmFibGVkID0gVFJVRTsKIAkJKHZvaWQpYWNwaV9ldl9yZW1vdmVfZ3BlX3JlZmVyZW5jZShncGVfZXZlbnRfaW5mbyk7CiAKQEAgLTgxNiw3ICs4MzUsMTAgQEAKIAogCWdwZV9ldmVudF9pbmZvLT5mbGFncyAmPQogCSAgICB+KEFDUElfR1BFX1hSVVBUX1RZUEVfTUFTSyB8IEFDUElfR1BFX0RJU1BBVENIX01BU0spOwotCWdwZV9ldmVudF9pbmZvLT5mbGFncyB8PSAodTgpKHR5cGUgfCBBQ1BJX0dQRV9ESVNQQVRDSF9IQU5ETEVSKTsKKwlncGVfZXZlbnRfaW5mby0+ZmxhZ3MgfD0KKwkgICAgKHU4KSh0eXBlIHwKKwkJIChpc19yYXdfaGFuZGxlciA/IEFDUElfR1BFX0RJU1BBVENIX1JBV19IQU5ETEVSIDoKKwkJICBBQ1BJX0dQRV9ESVNQQVRDSF9IQU5ETEVSKSk7CiAKIAlhY3BpX29zX3JlbGVhc2VfbG9jayhhY3BpX2dibF9ncGVfbG9jaywgZmxhZ3MpOwogCkBAIC04MzAsMTAgKzg1Miw3OCBAQAogCWdvdG8gdW5sb2NrX2FuZF9leGl0OwogfQogCisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICoKKyAqIEZVTkNUSU9OOiAgICBhY3BpX2luc3RhbGxfZ3BlX2hhbmRsZXIKKyAqCisgKiBQQVJBTUVURVJTOiAgZ3BlX2RldmljZSAgICAgIC0gTmFtZXNwYWNlIG5vZGUgZm9yIHRoZSBHUEUgKE5VTEwgZm9yIEZBRFQKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBkZWZpbmVkIEdQRXMpCisgKiAgICAgICAgICAgICAgZ3BlX251bWJlciAgICAgIC0gVGhlIEdQRSBudW1iZXIgd2l0aGluIHRoZSBHUEUgYmxvY2sKKyAqICAgICAgICAgICAgICB0eXBlICAgICAgICAgICAgLSBXaGV0aGVyIHRoaXMgR1BFIHNob3VsZCBiZSB0cmVhdGVkIGFzIGFuCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZWRnZS0gb3IgbGV2ZWwtdHJpZ2dlcmVkIGludGVycnVwdC4KKyAqICAgICAgICAgICAgICBhZGRyZXNzICAgICAgICAgLSBBZGRyZXNzIG9mIHRoZSBoYW5kbGVyCisgKiAgICAgICAgICAgICAgY29udGV4dCAgICAgICAgIC0gVmFsdWUgcGFzc2VkIHRvIHRoZSBoYW5kbGVyIG9uIGVhY2ggR1BFCisgKgorICogUkVUVVJOOiAgICAgIFN0YXR1cworICoKKyAqIERFU0NSSVBUSU9OOiBJbnN0YWxsIGEgaGFuZGxlciBmb3IgYSBHZW5lcmFsIFB1cnBvc2UgRXZlbnQuCisgKgorICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKworYWNwaV9zdGF0dXMKK2FjcGlfaW5zdGFsbF9ncGVfaGFuZGxlcihhY3BpX2hhbmRsZSBncGVfZGV2aWNlLAorCQkJIHUzMiBncGVfbnVtYmVyLAorCQkJIHUzMiB0eXBlLCBhY3BpX2dwZV9oYW5kbGVyIGFkZHJlc3MsIHZvaWQgKmNvbnRleHQpCit7CisJYWNwaV9zdGF0dXMgc3RhdHVzOworCisJQUNQSV9GVU5DVElPTl9UUkFDRShhY3BpX2luc3RhbGxfZ3BlX2hhbmRsZXIpOworCisJc3RhdHVzID0KKwkgICAgYWNwaV9ldl9pbnN0YWxsX2dwZV9oYW5kbGVyKGdwZV9kZXZpY2UsIGdwZV9udW1iZXIsIHR5cGUsIEZBTFNFLAorCQkJCQlhZGRyZXNzLCBjb250ZXh0KTsKKworCXJldHVybl9BQ1BJX1NUQVRVUyhzdGF0dXMpOworfQorCiBBQ1BJX0VYUE9SVF9TWU1CT0woYWNwaV9pbnN0YWxsX2dwZV9oYW5kbGVyKQogCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogICoKKyAqIEZVTkNUSU9OOiAgICBhY3BpX2luc3RhbGxfZ3BlX3Jhd19oYW5kbGVyCisgKgorICogUEFSQU1FVEVSUzogIGdwZV9kZXZpY2UgICAgICAtIE5hbWVzcGFjZSBub2RlIGZvciB0aGUgR1BFIChOVUxMIGZvciBGQURUCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZGVmaW5lZCBHUEVzKQorICogICAgICAgICAgICAgIGdwZV9udW1iZXIgICAgICAtIFRoZSBHUEUgbnVtYmVyIHdpdGhpbiB0aGUgR1BFIGJsb2NrCisgKiAgICAgICAgICAgICAgdHlwZSAgICAgICAgICAgIC0gV2hldGhlciB0aGlzIEdQRSBzaG91bGQgYmUgdHJlYXRlZCBhcyBhbgorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGVkZ2UtIG9yIGxldmVsLXRyaWdnZXJlZCBpbnRlcnJ1cHQuCisgKiAgICAgICAgICAgICAgYWRkcmVzcyAgICAgICAgIC0gQWRkcmVzcyBvZiB0aGUgaGFuZGxlcgorICogICAgICAgICAgICAgIGNvbnRleHQgICAgICAgICAtIFZhbHVlIHBhc3NlZCB0byB0aGUgaGFuZGxlciBvbiBlYWNoIEdQRQorICoKKyAqIFJFVFVSTjogICAgICBTdGF0dXMKKyAqCisgKiBERVNDUklQVElPTjogSW5zdGFsbCBhIGhhbmRsZXIgZm9yIGEgR2VuZXJhbCBQdXJwb3NlIEV2ZW50LgorICoKKyAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCithY3BpX3N0YXR1cworYWNwaV9pbnN0YWxsX2dwZV9yYXdfaGFuZGxlcihhY3BpX2hhbmRsZSBncGVfZGV2aWNlLAorCQkJICAgICB1MzIgZ3BlX251bWJlciwKKwkJCSAgICAgdTMyIHR5cGUsIGFjcGlfZ3BlX2hhbmRsZXIgYWRkcmVzcywgdm9pZCAqY29udGV4dCkKK3sKKwlhY3BpX3N0YXR1cyBzdGF0dXM7CisKKwlBQ1BJX0ZVTkNUSU9OX1RSQUNFKGFjcGlfaW5zdGFsbF9ncGVfcmF3X2hhbmRsZXIpOworCisJc3RhdHVzID0gYWNwaV9ldl9pbnN0YWxsX2dwZV9oYW5kbGVyKGdwZV9kZXZpY2UsIGdwZV9udW1iZXIsIHR5cGUsIFRSVUUsCisJCQkJCSAgICAgYWRkcmVzcywgY29udGV4dCk7CisKKwlyZXR1cm5fQUNQSV9TVEFUVVMoc3RhdHVzKTsKK30KKworQUNQSV9FWFBPUlRfU1lNQk9MKGFjcGlfaW5zdGFsbF9ncGVfcmF3X2hhbmRsZXIpCisKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKgogICogRlVOQ1RJT046ICAgIGFjcGlfcmVtb3ZlX2dwZV9oYW5kbGVyCiAgKgogICogUEFSQU1FVEVSUzogIGdwZV9kZXZpY2UgICAgICAtIE5hbWVzcGFjZSBub2RlIGZvciB0aGUgR1BFIChOVUxMIGZvciBGQURUCkBAIC04ODAsOCArOTcwLDEwIEBACiAKIAkvKiBNYWtlIHN1cmUgdGhhdCBhIGhhbmRsZXIgaXMgaW5kZWVkIGluc3RhbGxlZCAqLwogCi0JaWYgKChncGVfZXZlbnRfaW5mby0+ZmxhZ3MgJiBBQ1BJX0dQRV9ESVNQQVRDSF9NQVNLKSAhPQotCSAgICBBQ1BJX0dQRV9ESVNQQVRDSF9IQU5ETEVSKSB7CisJaWYgKChBQ1BJX0dQRV9ESVNQQVRDSF9UWVBFKGdwZV9ldmVudF9pbmZvLT5mbGFncykgIT0KKwkgICAgIEFDUElfR1BFX0RJU1BBVENIX0hBTkRMRVIpICYmCisJICAgIChBQ1BJX0dQRV9ESVNQQVRDSF9UWVBFKGdwZV9ldmVudF9pbmZvLT5mbGFncykgIT0KKwkgICAgIEFDUElfR1BFX0RJU1BBVENIX1JBV19IQU5ETEVSKSkgewogCQlzdGF0dXMgPSBBRV9OT1RfRVhJU1Q7CiAJCWdvdG8gdW5sb2NrX2FuZF9leGl0OwogCX0KQEAgLTg5Niw2ICs5ODgsNyBAQAogCS8qIFJlbW92ZSB0aGUgaGFuZGxlciAqLwogCiAJaGFuZGxlciA9IGdwZV9ldmVudF9pbmZvLT5kaXNwYXRjaC5oYW5kbGVyOworCWdwZV9ldmVudF9pbmZvLT5kaXNwYXRjaC5oYW5kbGVyID0gTlVMTDsKIAogCS8qIFJlc3RvcmUgTWV0aG9kIG5vZGUgKGlmIGFueSksIHNldCBkaXNwYXRjaCBmbGFncyAqLwogCkBAIC05MDksOSArMTAwMiwxMCBAQAogCSAqIGVuYWJsZWQsIGl0IHNob3VsZCBiZSBlbmFibGVkIGF0IHRoaXMgcG9pbnQgdG8gcmVzdG9yZSB0aGUKIAkgKiBwb3N0LWluaXRpYWxpemF0aW9uIGNvbmZpZ3VyYXRpb24uCiAJICovCi0JaWYgKCgoaGFuZGxlci0+b3JpZ2luYWxfZmxhZ3MgJiBBQ1BJX0dQRV9ESVNQQVRDSF9NRVRIT0QpIHx8Ci0JICAgICAoaGFuZGxlci0+b3JpZ2luYWxfZmxhZ3MgJiBBQ1BJX0dQRV9ESVNQQVRDSF9OT1RJRlkpKSAmJgotCSAgICBoYW5kbGVyLT5vcmlnaW5hbGx5X2VuYWJsZWQpIHsKKwlpZiAoKChBQ1BJX0dQRV9ESVNQQVRDSF9UWVBFKGhhbmRsZXItPm9yaWdpbmFsX2ZsYWdzKSA9PQorCSAgICAgIEFDUElfR1BFX0RJU1BBVENIX01FVEhPRCkgfHwKKwkgICAgIChBQ1BJX0dQRV9ESVNQQVRDSF9UWVBFKGhhbmRsZXItPm9yaWdpbmFsX2ZsYWdzKSA9PQorCSAgICAgIEFDUElfR1BFX0RJU1BBVENIX05PVElGWSkpICYmIGhhbmRsZXItPm9yaWdpbmFsbHlfZW5hYmxlZCkgewogCQkodm9pZClhY3BpX2V2X2FkZF9ncGVfcmVmZXJlbmNlKGdwZV9ldmVudF9pbmZvKTsKIAl9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZ4ZmV2bnQuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZ4ZmV2bnQuYwppbmRleCBiYjhjYmY1Li5kZjA2YTIzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2eGZldm50LmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9ldnhmZXZudC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9ldnhmZ3BlLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2eGZncGUuYwppbmRleCBlODg5YTUzLi43MGViNDdlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2eGZncGUuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2eGZncGUuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKQEAgLTEzMiw3ICsxMzIsNyBAQAogCSAqLwogCWdwZV9ldmVudF9pbmZvID0gYWNwaV9ldl9nZXRfZ3BlX2V2ZW50X2luZm8oZ3BlX2RldmljZSwgZ3BlX251bWJlcik7CiAJaWYgKGdwZV9ldmVudF9pbmZvKSB7Ci0JCWlmICgoZ3BlX2V2ZW50X2luZm8tPmZsYWdzICYgQUNQSV9HUEVfRElTUEFUQ0hfTUFTSykgIT0KKwkJaWYgKEFDUElfR1BFX0RJU1BBVENIX1RZUEUoZ3BlX2V2ZW50X2luZm8tPmZsYWdzKSAhPQogCQkgICAgQUNQSV9HUEVfRElTUEFUQ0hfTk9ORSkgewogCQkJc3RhdHVzID0gYWNwaV9ldl9hZGRfZ3BlX3JlZmVyZW5jZShncGVfZXZlbnRfaW5mbyk7CiAJCX0gZWxzZSB7CkBAIC0xODMsNiArMTgzLDc3IEBACiAKIEFDUElfRVhQT1JUX1NZTUJPTChhY3BpX2Rpc2FibGVfZ3BlKQogCisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICoKKyAqIEZVTkNUSU9OOiAgICBhY3BpX3NldF9ncGUKKyAqCisgKiBQQVJBTUVURVJTOiAgZ3BlX2RldmljZSAgICAgICAgICAtIFBhcmVudCBHUEUgRGV2aWNlLiBOVUxMIGZvciBHUEUwL0dQRTEKKyAqICAgICAgICAgICAgICBncGVfbnVtYmVyICAgICAgICAgIC0gR1BFIGxldmVsIHdpdGhpbiB0aGUgR1BFIGJsb2NrCisgKiAgICAgICAgICAgICAgYWN0aW9uICAgICAgICAgICAgICAtIEFDUElfR1BFX0VOQUJMRSBvciBBQ1BJX0dQRV9ESVNBQkxFCisgKgorICogUkVUVVJOOiAgICAgIFN0YXR1cworICoKKyAqIERFU0NSSVBUSU9OOiBFbmFibGUgb3IgZGlzYWJsZSBhbiBpbmRpdmlkdWFsIEdQRS4gVGhpcyBmdW5jdGlvbiBieXBhc3NlcworICogICAgICAgICAgICAgIHRoZSByZWZlcmVuY2UgY291bnQgbWVjaGFuaXNtIHVzZWQgaW4gdGhlIGFjcGlfZW5hYmxlX2dwZSgpLAorICogICAgICAgICAgICAgIGFjcGlfZGlzYWJsZV9ncGUoKSBpbnRlcmZhY2VzLgorICogICAgICAgICAgICAgIFRoaXMgQVBJIGlzIHR5cGljYWxseSB1c2VkIGJ5IHRoZSBHUEUgcmF3IGhhbmRsZXIgbW9kZSBkcml2ZXIKKyAqICAgICAgICAgICAgICB0byBzd2l0Y2ggYmV0d2VlbiB0aGUgcG9sbGluZyBtb2RlIGFuZCB0aGUgaW50ZXJydXB0IG1vZGUgYWZ0ZXIKKyAqICAgICAgICAgICAgICB0aGUgZHJpdmVyIGhhcyBlbmFibGVkIHRoZSBHUEUuCisgKiAgICAgICAgICAgICAgVGhlIEFQSXMgc2hvdWxkIGJlIGludm9rZWQgaW4gdGhpcyBvcmRlcjoKKyAqICAgICAgICAgICAgICAgYWNwaV9lbmFibGVfZ3BlKCkgICAgICAgICAgICA8LSBFbnN1cmUgdGhlIHJlZmVyZW5jZSBjb3VudCA+IDAKKyAqICAgICAgICAgICAgICAgYWNwaV9zZXRfZ3BlKEFDUElfR1BFX0RJU0FCTEUpIDwtIEVudGVyIHBvbGxpbmcgbW9kZQorICogICAgICAgICAgICAgICBhY3BpX3NldF9ncGUoQUNQSV9HUEVfRU5BQkxFKSA8LSBMZWF2ZSBwb2xsaW5nIG1vZGUKKyAqICAgICAgICAgICAgICAgYWNwaV9kaXNhYmxlX2dwZSgpICAgICAgICAgICA8LSBEZWNyZWFzZSB0aGUgcmVmZXJlbmNlIGNvdW50CisgKgorICogTm90ZTogSWYgYSBHUEUgaXMgc2hhcmVkIGJ5IDIgc2lsaWNvbiBjb21wb25lbnRzLCB0aGVuIGJvdGggdGhlIGRyaXZlcnMKKyAqICAgICAgIHNob3VsZCBzdXBwb3J0IEdQRSBwb2xsaW5nIG1vZGUgb3IgZGlzYWJsaW5nIHRoZSBHUEUgZm9yIGxvbmcgcGVyaW9kCisgKiAgICAgICBmb3Igb25lIGRyaXZlciBtYXkgYnJlYWsgdGhlIG90aGVyLiBTbyB1c2UgaXQgd2l0aCBjYXJlIHNpbmNlIGFsbAorICogICAgICAgZmlybXdhcmUgX0x4eC9fRXh4IGhhbmRsZXJzIGN1cnJlbnRseSByZWx5IG9uIHRoZSBHUEUgaW50ZXJydXB0IG1vZGUuCisgKgorICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KK2FjcGlfc3RhdHVzIGFjcGlfc2V0X2dwZShhY3BpX2hhbmRsZSBncGVfZGV2aWNlLCB1MzIgZ3BlX251bWJlciwgdTggYWN0aW9uKQoreworCXN0cnVjdCBhY3BpX2dwZV9ldmVudF9pbmZvICpncGVfZXZlbnRfaW5mbzsKKwlhY3BpX3N0YXR1cyBzdGF0dXM7CisJYWNwaV9jcHVfZmxhZ3MgZmxhZ3M7CisKKwlBQ1BJX0ZVTkNUSU9OX1RSQUNFKGFjcGlfc2V0X2dwZSk7CisKKwlmbGFncyA9IGFjcGlfb3NfYWNxdWlyZV9sb2NrKGFjcGlfZ2JsX2dwZV9sb2NrKTsKKworCS8qIEVuc3VyZSB0aGF0IHdlIGhhdmUgYSB2YWxpZCBHUEUgbnVtYmVyICovCisKKwlncGVfZXZlbnRfaW5mbyA9IGFjcGlfZXZfZ2V0X2dwZV9ldmVudF9pbmZvKGdwZV9kZXZpY2UsIGdwZV9udW1iZXIpOworCWlmICghZ3BlX2V2ZW50X2luZm8pIHsKKwkJc3RhdHVzID0gQUVfQkFEX1BBUkFNRVRFUjsKKwkJZ290byB1bmxvY2tfYW5kX2V4aXQ7CisJfQorCisJLyogUGVyZm9ybSB0aGUgYWN0aW9uICovCisKKwlzd2l0Y2ggKGFjdGlvbikgeworCWNhc2UgQUNQSV9HUEVfRU5BQkxFOgorCisJCXN0YXR1cyA9IGFjcGlfaHdfbG93X3NldF9ncGUoZ3BlX2V2ZW50X2luZm8sIEFDUElfR1BFX0VOQUJMRSk7CisJCWJyZWFrOworCisJY2FzZSBBQ1BJX0dQRV9ESVNBQkxFOgorCisJCXN0YXR1cyA9IGFjcGlfaHdfbG93X3NldF9ncGUoZ3BlX2V2ZW50X2luZm8sIEFDUElfR1BFX0RJU0FCTEUpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisKKwkJc3RhdHVzID0gQUVfQkFEX1BBUkFNRVRFUjsKKwkJYnJlYWs7CisJfQorCit1bmxvY2tfYW5kX2V4aXQ6CisJYWNwaV9vc19yZWxlYXNlX2xvY2soYWNwaV9nYmxfZ3BlX2xvY2ssIGZsYWdzKTsKKwlyZXR1cm5fQUNQSV9TVEFUVVMoc3RhdHVzKTsKK30KKworQUNQSV9FWFBPUlRfU1lNQk9MKGFjcGlfc2V0X2dwZSkKIAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICAqCkBAIC0zMTMsNyArMzg0LDcgQEAKIAkgKiBrbm93biBhcyBhbiAiaW1wbGljaXQgbm90aWZ5Ii4gTm90ZTogVGhlIEdQRSBpcyBhc3N1bWVkIHRvIGJlCiAJICogbGV2ZWwtdHJpZ2dlcmVkIChmb3Igd2luZG93cyBjb21wYXRpYmlsaXR5KS4KIAkgKi8KLQlpZiAoKGdwZV9ldmVudF9pbmZvLT5mbGFncyAmIEFDUElfR1BFX0RJU1BBVENIX01BU0spID09CisJaWYgKEFDUElfR1BFX0RJU1BBVENIX1RZUEUoZ3BlX2V2ZW50X2luZm8tPmZsYWdzKSA9PQogCSAgICBBQ1BJX0dQRV9ESVNQQVRDSF9OT05FKSB7CiAJCS8qCiAJCSAqIFRoaXMgaXMgdGhlIGZpcnN0IGRldmljZSBmb3IgaW1wbGljaXQgbm90aWZ5IG9uIHRoaXMgR1BFLgpAQCAtMzI3LDcgKzM5OCw3IEBACiAJICogSWYgd2UgYWxyZWFkeSBoYXZlIGFuIGltcGxpY2l0IG5vdGlmeSBvbiB0aGlzIEdQRSwgYWRkCiAJICogdGhpcyBkZXZpY2UgdG8gdGhlIG5vdGlmeSBsaXN0LgogCSAqLwotCWlmICgoZ3BlX2V2ZW50X2luZm8tPmZsYWdzICYgQUNQSV9HUEVfRElTUEFUQ0hfTUFTSykgPT0KKwlpZiAoQUNQSV9HUEVfRElTUEFUQ0hfVFlQRShncGVfZXZlbnRfaW5mby0+ZmxhZ3MpID09CiAJICAgIEFDUElfR1BFX0RJU1BBVENIX05PVElGWSkgewogCiAJCS8qIEVuc3VyZSB0aGF0IHRoZSBkZXZpY2UgaXMgbm90IGFscmVhZHkgaW4gdGhlIGxpc3QgKi8KQEAgLTUzMCw2ICs2MDEsNDkgQEAKIAogQUNQSV9FWFBPUlRfU1lNQk9MKGFjcGlfZ2V0X2dwZV9zdGF0dXMpCiAKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKgorICogRlVOQ1RJT046ICAgIGFjcGlfZmluaXNoX2dwZQorICoKKyAqIFBBUkFNRVRFUlM6ICBncGVfZGV2aWNlICAgICAgICAgIC0gTmFtZXNwYWNlIG5vZGUgZm9yIHRoZSBHUEUgQmxvY2sKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKE5VTEwgZm9yIEZBRFQgZGVmaW5lZCBHUEVzKQorICogICAgICAgICAgICAgIGdwZV9udW1iZXIgICAgICAgICAgLSBHUEUgbGV2ZWwgd2l0aGluIHRoZSBHUEUgYmxvY2sKKyAqCisgKiBSRVRVUk46ICAgICAgU3RhdHVzCisgKgorICogREVTQ1JJUFRJT046IENsZWFyIGFuZCBjb25kaXRpb25hbGx5IHJlZW5hYmxlIGEgR1BFLiBUaGlzIGNvbXBsZXRlcyB0aGUgR1BFCisgKiAgICAgICAgICAgICAgcHJvY2Vzc2luZy4gSW50ZW5kZWQgZm9yIHVzZSBieSBhc3luY2hyb25vdXMgaG9zdC1pbnN0YWxsZWQKKyAqICAgICAgICAgICAgICBHUEUgaGFuZGxlcnMuIFRoZSBHUEUgaXMgb25seSByZWVuYWJsZWQgaWYgdGhlIGVuYWJsZV9mb3JfcnVuIGJpdAorICogICAgICAgICAgICAgIGlzIHNldCBpbiB0aGUgR1BFIGluZm8uCisgKgorICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KK2FjcGlfc3RhdHVzIGFjcGlfZmluaXNoX2dwZShhY3BpX2hhbmRsZSBncGVfZGV2aWNlLCB1MzIgZ3BlX251bWJlcikKK3sKKwlzdHJ1Y3QgYWNwaV9ncGVfZXZlbnRfaW5mbyAqZ3BlX2V2ZW50X2luZm87CisJYWNwaV9zdGF0dXMgc3RhdHVzOworCWFjcGlfY3B1X2ZsYWdzIGZsYWdzOworCisJQUNQSV9GVU5DVElPTl9UUkFDRShhY3BpX2ZpbmlzaF9ncGUpOworCisJZmxhZ3MgPSBhY3BpX29zX2FjcXVpcmVfbG9jayhhY3BpX2dibF9ncGVfbG9jayk7CisKKwkvKiBFbnN1cmUgdGhhdCB3ZSBoYXZlIGEgdmFsaWQgR1BFIG51bWJlciAqLworCisJZ3BlX2V2ZW50X2luZm8gPSBhY3BpX2V2X2dldF9ncGVfZXZlbnRfaW5mbyhncGVfZGV2aWNlLCBncGVfbnVtYmVyKTsKKwlpZiAoIWdwZV9ldmVudF9pbmZvKSB7CisJCXN0YXR1cyA9IEFFX0JBRF9QQVJBTUVURVI7CisJCWdvdG8gdW5sb2NrX2FuZF9leGl0OworCX0KKworCXN0YXR1cyA9IGFjcGlfZXZfZmluaXNoX2dwZShncGVfZXZlbnRfaW5mbyk7CisKK3VubG9ja19hbmRfZXhpdDoKKwlhY3BpX29zX3JlbGVhc2VfbG9jayhhY3BpX2dibF9ncGVfbG9jaywgZmxhZ3MpOworCXJldHVybl9BQ1BJX1NUQVRVUyhzdGF0dXMpOworfQorCitBQ1BJX0VYUE9SVF9TWU1CT0woYWNwaV9maW5pc2hfZ3BlKQorCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAgKgogICogRlVOQ1RJT046ICAgIGFjcGlfZGlzYWJsZV9hbGxfZ3BlcwpAQCAtNjA0LDcgKzcxOCw2IEBACiAgKiAgICAgICAgICAgICAgYWxsIEdQRSBibG9ja3MuCiAgKgogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLQogYWNwaV9zdGF0dXMgYWNwaV9lbmFibGVfYWxsX3dha2V1cF9ncGVzKHZvaWQpCiB7CiAJYWNwaV9zdGF0dXMgc3RhdHVzOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9ldnhmcmVnbi5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9ldnhmcmVnbi5jCmluZGV4IDJkNmYxODcuLmYyMWFmYmEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZ4ZnJlZ24uYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2eGZyZWduLmMKQEAgLTYsNyArNiw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4Y29uZmlnLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4Y29uZmlnLmMKaW5kZXggN2QyOTQ5NC4uNmUwZGYyYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9leGNvbmZpZy5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhjb25maWcuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhjb252cnQuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhjb252cnQuYwppbmRleCBjNTQ1Mzg2Li44OWE5NzZiIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4Y29udnJ0LmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9leGNvbnZydC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9leGNyZWF0ZS5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9leGNyZWF0ZS5jCmluZGV4IDk1ZDIzZGEuLmFhZWVhNDggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhjcmVhdGUuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4Y3JlYXRlLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4ZGVidWcuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhkZWJ1Zy5jCmluZGV4IDZmYmZhZDQuLmU2N2QwYWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhkZWJ1Zy5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhkZWJ1Zy5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9leGR1bXAuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhkdW1wLmMKaW5kZXggMGYyM2MzZi4uN2MyMTNiNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9leGR1bXAuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4ZHVtcC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9leGZpZWxkLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4ZmllbGQuYwppbmRleCBiOTk0ODQ1Li5jMTYxZGQ5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4ZmllbGQuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4ZmllbGQuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhmbGRpby5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9leGZsZGlvLmMKaW5kZXggMWQxYjI3YS4uNDk0Nzk5MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9leGZsZGlvLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9leGZsZGlvLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4bWlzYy5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9leG1pc2MuYwppbmRleCAyMjA3ZTYyLi5iNTZmYzlkIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4bWlzYy5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhtaXNjLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4bXV0ZXguYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhtdXRleC5jCmluZGV4IGI0OWVhMmEuLjQ3MjAzMGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhtdXRleC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhtdXRleC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9leG5hbWVzLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4bmFtZXMuYwppbmRleCBkYmIwM2I1NC4uNDUzYjAwYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9leG5hbWVzLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9leG5hbWVzLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4b3BhcmcxLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4b3BhcmcxLmMKaW5kZXggMWI4ZTk0MS4uNzc5MzA2OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9leG9wYXJnMS5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhvcGFyZzEuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhvcGFyZzIuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhvcGFyZzIuYwppbmRleCAyZWRlNjU2Li5mY2M2MThhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4b3BhcmcyLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9leG9wYXJnMi5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9leG9wYXJnMy5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9leG9wYXJnMy5jCmluZGV4IDM2Mzc2N2MuLmI4MTNmZWQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhvcGFyZzMuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4b3BhcmczLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4b3Bhcmc2LmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4b3Bhcmc2LmMKaW5kZXggMjllOWU5OS4uYzkzMGVkZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9leG9wYXJnNi5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhvcGFyZzYuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhwcmVwLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4cHJlcC5jCmluZGV4IDExOGU5NDIuLjRjMjgzNmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhwcmVwLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9leHByZXAuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhyZWdpb24uYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhyZWdpb24uYwppbmRleCBjZDUyODhhLi4wZmUxODhlMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9leHJlZ2lvbi5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhyZWdpb24uYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhyZXNudGUuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhyZXNudGUuYwppbmRleCBhYjA2MDI2Li5jN2UzYjkyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4cmVzbnRlLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9leHJlc250ZS5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9leHJlc29sdi5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9leHJlc29sdi5jCmluZGV4IDNjZGU1NTMuLmI2YjdmM2EgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhyZXNvbHYuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4cmVzb2x2LmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4cmVzb3AuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhyZXNvcC5jCmluZGV4IDNhZjhkZTMuLmQyOTY0YWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhyZXNvcC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhyZXNvcC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9leHN0b3JlLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4c3RvcmUuYwppbmRleCBkYWY0OWY3Li5hN2VlZTI0IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4c3RvcmUuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4c3RvcmUuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhzdG9yZW4uYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhzdG9yZW4uYwppbmRleCAwNGJkMTZjLi4zMTAxNjA3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4c3RvcmVuLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9leHN0b3Jlbi5jCkBAIC02LDcgKzYsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9leHN0b3JvYi5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9leHN0b3JvYi5jCmluZGV4IGZkMTEwMTguLjZmYTNjOGQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhzdG9yb2IuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4c3Rvcm9iLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4c3lzdGVtLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4c3lzdGVtLmMKaW5kZXggZjdkYTY0MS4uMDU0NTA2NSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9leHN5c3RlbS5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhzeXN0ZW0uYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXh1dGlscy5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9leHV0aWxzLmMKaW5kZXggZDlkNzJkZi4uM2Y0MjI1ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9leHV0aWxzLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9leHV0aWxzLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2h3YWNwaS5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9od2FjcGkuYwppbmRleCAxZTY2ZDk2Li5lNWM1OTQ5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2h3YWNwaS5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvaHdhY3BpLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2h3ZXNsZWVwLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2h3ZXNsZWVwLmMKaW5kZXggODU4ZmRkNi4uZTU1OTlmNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9od2VzbGVlcC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvaHdlc2xlZXAuYwpAQCAtNiw3ICs2LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvaHdncGUuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvaHdncGUuYwppbmRleCA0OTQwMjdmNS4uODRiYzU1MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9od2dwZS5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvaHdncGUuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKQEAgLTU0LDYgKzU0LDEwIEBACiAJCQkJc3RydWN0IGFjcGlfZ3BlX2Jsb2NrX2luZm8gKmdwZV9ibG9jaywKIAkJCQl2b2lkICpjb250ZXh0KTsKIAorc3RhdGljIGFjcGlfc3RhdHVzCithY3BpX2h3X2dwZV9lbmFibGVfd3JpdGUodTggZW5hYmxlX21hc2ssCisJCQkgc3RydWN0IGFjcGlfZ3BlX3JlZ2lzdGVyX2luZm8gKmdwZV9yZWdpc3Rlcl9pbmZvKTsKKwogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogICoKICAqIEZVTkNUSU9OOglhY3BpX2h3X2dldF9ncGVfcmVnaXN0ZXJfYml0CkBAIC0xNDYsNyArMTUwLDcgQEAKIAogCXN0YXR1cyA9IGFjcGlfaHdfd3JpdGUoZW5hYmxlX21hc2ssICZncGVfcmVnaXN0ZXJfaW5mby0+ZW5hYmxlX2FkZHJlc3MpOwogCWlmIChBQ1BJX1NVQ0NFU1Moc3RhdHVzKSAmJiAoYWN0aW9uICYgQUNQSV9HUEVfU0FWRV9NQVNLKSkgewotCQlncGVfcmVnaXN0ZXJfaW5mby0+ZW5hYmxlX21hc2sgPSBlbmFibGVfbWFzazsKKwkJZ3BlX3JlZ2lzdGVyX2luZm8tPmVuYWJsZV9tYXNrID0gKHU4KWVuYWJsZV9tYXNrOwogCX0KIAlyZXR1cm4gKHN0YXR1cyk7CiB9CkBAIC0yMjEsNyArMjI1LDcgQEAKIAogCS8qIEdQRSBjdXJyZW50bHkgaGFuZGxlZD8gKi8KIAotCWlmICgoZ3BlX2V2ZW50X2luZm8tPmZsYWdzICYgQUNQSV9HUEVfRElTUEFUQ0hfTUFTSykgIT0KKwlpZiAoQUNQSV9HUEVfRElTUEFUQ0hfVFlQRShncGVfZXZlbnRfaW5mby0+ZmxhZ3MpICE9CiAJICAgIEFDUElfR1BFX0RJU1BBVENIX05PTkUpIHsKIAkJbG9jYWxfZXZlbnRfc3RhdHVzIHw9IEFDUElfRVZFTlRfRkxBR19IQVNfSEFORExFUjsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2h3cGNpLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2h3cGNpLmMKaW5kZXggNmFhZGU4ZS4uYzUyMTRkZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9od3BjaS5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvaHdwY2kuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2h3cmVncy5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9od3JlZ3MuYwppbmRleCBhNGMzNGQyLi4zY2Y3N2FmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2h3cmVncy5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvaHdyZWdzLmMKQEAgLTYsNyArNiw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9od3NsZWVwLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2h3c2xlZXAuYwppbmRleCBkNTkwNjkzLi43ZDIxY2FlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2h3c2xlZXAuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2h3c2xlZXAuYwpAQCAtNiw3ICs2LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvaHd0aW1lci5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9od3RpbWVyLmMKaW5kZXggNzZhYjVjMS4uNjc1YzcwOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9od3RpbWVyLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9od3RpbWVyLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2h3dmFsaWQuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvaHd2YWxpZC5jCmluZGV4IDZiOTE5MTIuLjJiZDMzZmUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvaHd2YWxpZC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvaHd2YWxpZC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9od3hmYWNlLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2h3eGZhY2UuYwppbmRleCA5NmQwMDdkZi4uNWY5NzQ2OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9od3hmYWNlLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9od3hmYWNlLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2h3eGZzbGVlcC5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9od3hmc2xlZXAuYwppbmRleCA2OTIxYzdmLi4zYjM3Njc2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2h3eGZzbGVlcC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvaHd4ZnNsZWVwLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL25zYWNjZXNzLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zYWNjZXNzLmMKaW5kZXggZjEyNDllMy4uMjRmYTE5YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc2FjY2Vzcy5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNhY2Nlc3MuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL25zYWxsb2MuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNhbGxvYy5jCmluZGV4IDYwN2ViOWUuLmUxMDdmOTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNhbGxvYy5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNhbGxvYy5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNhcmd1bWVudHMuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNhcmd1bWVudHMuYwppbmRleCA4MGZjZmM4Li41ZDM0N2E3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL25zYXJndW1lbnRzLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9uc2FyZ3VtZW50cy5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc2NvbnZlcnQuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNjb252ZXJ0LmMKaW5kZXggYjU1NjQyYy4uMWE4YjM5YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc2NvbnZlcnQuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zY29udmVydC5jCkBAIC02LDcgKzYsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc2R1bXAuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNkdW1wLmMKaW5kZXggM2Q4OGVmNC4uODBmMDk3ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc2R1bXAuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zZHVtcC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc2R1bXBkdi5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9uc2R1bXBkdi5jCmluZGV4IDQyZDM3MTAuLjdkYzM2N2UgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNkdW1wZHYuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zZHVtcGR2LmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL25zZXZhbC5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9uc2V2YWwuYwppbmRleCBlNjM0YTA1Li43YmNjNjhmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL25zZXZhbC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNldmFsLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc2luaXQuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNpbml0LmMKaW5kZXggYTNmYjdlNC4uNGE4NWM0NSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc2luaXQuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zaW5pdC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc2xvYWQuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNsb2FkLmMKaW5kZXggN2M5ZDAxOC4uYmQ2Y2Q0YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc2xvYWQuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zbG9hZC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc25hbWVzLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zbmFtZXMuYwppbmRleCA3ZWVlMGE2Li5kMjkzZDk3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL25zbmFtZXMuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zbmFtZXMuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL25zb2JqZWN0LmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zb2JqZWN0LmMKaW5kZXggYTQyZWU5ZC4uNjc3YmM5MyAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc29iamVjdC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNvYmplY3QuYwpAQCAtNiw3ICs2LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL25zcGFyc2UuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNwYXJzZS5jCmluZGV4IGU4M2NmZjMuLmM5NWExMTkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNwYXJzZS5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNwYXJzZS5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc3ByZWRlZi5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9uc3ByZWRlZi5jCmluZGV4IDM5MjkxMGYuLjBlYjU0MzEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNwcmVkZWYuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zcHJlZGVmLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL25zcHJlcGtnLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zcHJlcGtnLmMKaW5kZXggMWIxM2I5Mi4uOGI3OTk1OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc3ByZXBrZy5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNwcmVwa2cuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNyZXBhaXIuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNyZXBhaXIuYwppbmRleCA3ZTQxN2FhLi4xNTFmY2Q5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL25zcmVwYWlyLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9uc3JlcGFpci5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc3JlcGFpcjIuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNyZXBhaXIyLmMKaW5kZXggYjA5ZTZiZS4uYzMwNjcyZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc3JlcGFpcjIuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zcmVwYWlyMi5jCkBAIC02LDcgKzYsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc3NlYXJjaC5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9uc3NlYXJjaC5jCmluZGV4IGFmMWNjNDIuLjRhOWQ0YTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNzZWFyY2guYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zc2VhcmNoLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc3V0aWxzLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zdXRpbHMuYwppbmRleCA0YTVlM2Y1Li42YWQwMjAwIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL25zdXRpbHMuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zdXRpbHMuYwpAQCAtNiw3ICs2LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnN3YWxrLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zd2Fsay5jCmluZGV4IDQ3NThhMWYuLmM2ODYwOWEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnN3YWxrLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9uc3dhbGsuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnN4ZmV2YWwuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnN4ZmV2YWwuYwppbmRleCA0YmQ1NThiLi5iNjAzMGEyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL25zeGZldmFsLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9uc3hmZXZhbC5jCkBAIC02LDcgKzYsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnN4Zm5hbWUuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnN4Zm5hbWUuYwppbmRleCA4YzZjMTFjLi5kNjZjMzI2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL25zeGZuYW1lLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9uc3hmbmFtZS5jCkBAIC02LDcgKzYsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc3hmb2JqLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zeGZvYmouYwppbmRleCBkYWU5NDAxLi43OTMzODM1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL25zeGZvYmouYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zeGZvYmouYwpAQCAtNiw3ICs2LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CkBAIC01Myw1MCArNTMsNiBAQAogCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogICoKLSAqIEZVTkNUSU9OOiAgICBhY3BpX2dldF9pZAotICoKLSAqIFBBUkFNRVRFUlM6ICBIYW5kbGUgICAgICAgICAgLSBIYW5kbGUgb2Ygb2JqZWN0IHdob3NlIGlkIGlzIGRlc2lyZWQKLSAqICAgICAgICAgICAgICByZXRfaWQgICAgICAgICAgLSBXaGVyZSB0aGUgaWQgd2lsbCBiZSBwbGFjZWQKLSAqCi0gKiBSRVRVUk46ICAgICAgU3RhdHVzCi0gKgotICogREVTQ1JJUFRJT046IFRoaXMgcm91dGluZSByZXR1cm5zIHRoZSBvd25lciBpZCBhc3NvY2lhdGVkIHdpdGggYSBoYW5kbGUKLSAqCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotYWNwaV9zdGF0dXMgYWNwaV9nZXRfaWQoYWNwaV9oYW5kbGUgaGFuZGxlLCBhY3BpX293bmVyX2lkICogcmV0X2lkKQotewotCXN0cnVjdCBhY3BpX25hbWVzcGFjZV9ub2RlICpub2RlOwotCWFjcGlfc3RhdHVzIHN0YXR1czsKLQotCS8qIFBhcmFtZXRlciBWYWxpZGF0aW9uICovCi0KLQlpZiAoIXJldF9pZCkgewotCQlyZXR1cm4gKEFFX0JBRF9QQVJBTUVURVIpOwotCX0KLQotCXN0YXR1cyA9IGFjcGlfdXRfYWNxdWlyZV9tdXRleChBQ1BJX01UWF9OQU1FU1BBQ0UpOwotCWlmIChBQ1BJX0ZBSUxVUkUoc3RhdHVzKSkgewotCQlyZXR1cm4gKHN0YXR1cyk7Ci0JfQotCi0JLyogQ29udmVydCBhbmQgdmFsaWRhdGUgdGhlIGhhbmRsZSAqLwotCi0Jbm9kZSA9IGFjcGlfbnNfdmFsaWRhdGVfaGFuZGxlKGhhbmRsZSk7Ci0JaWYgKCFub2RlKSB7Ci0JCSh2b2lkKWFjcGlfdXRfcmVsZWFzZV9tdXRleChBQ1BJX01UWF9OQU1FU1BBQ0UpOwotCQlyZXR1cm4gKEFFX0JBRF9QQVJBTUVURVIpOwotCX0KLQotCSpyZXRfaWQgPSBub2RlLT5vd25lcl9pZDsKLQotCXN0YXR1cyA9IGFjcGlfdXRfcmVsZWFzZV9tdXRleChBQ1BJX01UWF9OQU1FU1BBQ0UpOwotCXJldHVybiAoc3RhdHVzKTsKLX0KLQotQUNQSV9FWFBPUlRfU1lNQk9MKGFjcGlfZ2V0X2lkKQotCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICoKICAqIEZVTkNUSU9OOiAgICBhY3BpX2dldF90eXBlCiAgKgogICogUEFSQU1FVEVSUzogIGhhbmRsZSAgICAgICAgICAtIEhhbmRsZSBvZiBvYmplY3Qgd2hvc2UgdHlwZSBpcyBkZXNpcmVkCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3BzYXJncy5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9wc2FyZ3MuYwppbmRleCAzMTRkMzE0Li42ZDAzODc3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3BzYXJncy5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcHNhcmdzLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3BzbG9vcC5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9wc2xvb3AuYwppbmRleCBiMDU4ZTIzLi45MDQzNzIyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3BzbG9vcC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcHNsb29wLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3Bzb2JqZWN0LmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3Bzb2JqZWN0LmMKaW5kZXggYTY4ODUwNy4uMmY1ZGRkOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9wc29iamVjdC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcHNvYmplY3QuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvcHNvcGNvZGUuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcHNvcGNvZGUuYwppbmRleCAxNzU1ZDJhLi4xYWY0YTQwIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3Bzb3Bjb2RlLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9wc29wY29kZS5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9wc29waW5mby5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9wc29waW5mby5jCmluZGV4IDBkOGQzN2YuLmUxOGU3YzQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvcHNvcGluZm8uYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3Bzb3BpbmZvLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3BzcGFyc2UuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcHNwYXJzZS5jCmluZGV4IDZkMjdiNTkuLmE1NTVmN2YgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvcHNwYXJzZS5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcHNwYXJzZS5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9wc3Njb3BlLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3Bzc2NvcGUuYwppbmRleCAzMmQyNTBmLi45ZDY2OWNjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3Bzc2NvcGUuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3Bzc2NvcGUuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvcHN0cmVlLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3BzdHJlZS5jCmluZGV4IDBiNjQxODEuLjg5OTg0ZjMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvcHN0cmVlLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9wc3RyZWUuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvcHN1dGlscy5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9wc3V0aWxzLmMKaW5kZXggM2NkNDg4MC4uOTYwNTA1YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9wc3V0aWxzLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9wc3V0aWxzLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3Bzd2Fsay5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9wc3dhbGsuYwppbmRleCA5Y2IwN2UxLi5iYTVmNjkxIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3Bzd2Fsay5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcHN3YWxrLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3BzeGZhY2UuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcHN4ZmFjZS5jCmluZGV4IGUxMzVhY2EuLjg0MWE1ZWEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvcHN4ZmFjZS5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcHN4ZmFjZS5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9yc2FkZHIuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNhZGRyLmMKaW5kZXggOTE2ZmQwOS4uNjZkNDA2ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9yc2FkZHIuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzYWRkci5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKQEAgLTc0LDcgKzc0LDcgQEAKIAkgKiBBZGRyZXNzIFRyYW5zbGF0aW9uIE9mZnNldAogCSAqIEFkZHJlc3MgTGVuZ3RoCiAJICovCi0Je0FDUElfUlNDX01PVkUxNiwgQUNQSV9SU19PRkZTRVQoZGF0YS5hZGRyZXNzMTYuZ3JhbnVsYXJpdHkpLAorCXtBQ1BJX1JTQ19NT1ZFMTYsIEFDUElfUlNfT0ZGU0VUKGRhdGEuYWRkcmVzczE2LmFkZHJlc3MuZ3JhbnVsYXJpdHkpLAogCSBBTUxfT0ZGU0VUKGFkZHJlc3MxNi5ncmFudWxhcml0eSksCiAJIDV9LAogCkBAIC0xMTIsNyArMTEyLDcgQEAKIAkgKiBBZGRyZXNzIFRyYW5zbGF0aW9uIE9mZnNldAogCSAqIEFkZHJlc3MgTGVuZ3RoCiAJICovCi0Je0FDUElfUlNDX01PVkUzMiwgQUNQSV9SU19PRkZTRVQoZGF0YS5hZGRyZXNzMzIuZ3JhbnVsYXJpdHkpLAorCXtBQ1BJX1JTQ19NT1ZFMzIsIEFDUElfUlNfT0ZGU0VUKGRhdGEuYWRkcmVzczMyLmFkZHJlc3MuZ3JhbnVsYXJpdHkpLAogCSBBTUxfT0ZGU0VUKGFkZHJlc3MzMi5ncmFudWxhcml0eSksCiAJIDV9LAogCkBAIC0xNTAsNyArMTUwLDcgQEAKIAkgKiBBZGRyZXNzIFRyYW5zbGF0aW9uIE9mZnNldAogCSAqIEFkZHJlc3MgTGVuZ3RoCiAJICovCi0Je0FDUElfUlNDX01PVkU2NCwgQUNQSV9SU19PRkZTRVQoZGF0YS5hZGRyZXNzNjQuZ3JhbnVsYXJpdHkpLAorCXtBQ1BJX1JTQ19NT1ZFNjQsIEFDUElfUlNfT0ZGU0VUKGRhdGEuYWRkcmVzczY0LmFkZHJlc3MuZ3JhbnVsYXJpdHkpLAogCSBBTUxfT0ZGU0VUKGFkZHJlc3M2NC5ncmFudWxhcml0eSksCiAJIDV9LAogCkBAIC0xOTQsNyArMTk0LDggQEAKIAkgKiBBZGRyZXNzIExlbmd0aAogCSAqIFR5cGUtU3BlY2lmaWMgQXR0cmlidXRlCiAJICovCi0Je0FDUElfUlNDX01PVkU2NCwgQUNQSV9SU19PRkZTRVQoZGF0YS5leHRfYWRkcmVzczY0LmdyYW51bGFyaXR5KSwKKwl7QUNQSV9SU0NfTU9WRTY0LAorCSBBQ1BJX1JTX09GRlNFVChkYXRhLmV4dF9hZGRyZXNzNjQuYWRkcmVzcy5ncmFudWxhcml0eSksCiAJIEFNTF9PRkZTRVQoZXh0X2FkZHJlc3M2NC5ncmFudWxhcml0eSksCiAJIDZ9CiB9OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9yc2NhbGMuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNjYWxjLmMKaW5kZXggNjg5NTU2Ny4uY2I3MzlhNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9yc2NhbGMuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzY2FsYy5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNjcmVhdGUuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNjcmVhdGUuYwppbmRleCAwNDlkOWMyLi4xNTQzNGU0IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzY3JlYXRlLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9yc2NyZWF0ZS5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNkdW1wLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzZHVtcC5jCmluZGV4IGMzYzU2YjUuLjE1MzkzOTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNkdW1wLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9yc2R1bXAuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzZHVtcGluZm8uYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNkdW1waW5mby5jCmluZGV4IDJmOTMzMmQuLmIyOWQ5ZWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNkdW1waW5mby5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNkdW1waW5mby5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKQEAgLTE4MywxNSArMTgzLDE1IEBACiAJe0FDUElfUlNEX1RJVExFLCBBQ1BJX1JTRF9UQUJMRV9TSVpFKGFjcGlfcnNfZHVtcF9hZGRyZXNzMTYpLAogCSAiMTYtQml0IFdPUkQgQWRkcmVzcyBTcGFjZSIsIE5VTEx9LAogCXtBQ1BJX1JTRF9BRERSRVNTLCAwLCBOVUxMLCBOVUxMfSwKLQl7QUNQSV9SU0RfVUlOVDE2LCBBQ1BJX1JTRF9PRkZTRVQoYWRkcmVzczE2LmdyYW51bGFyaXR5KSwgIkdyYW51bGFyaXR5IiwKLQkgTlVMTH0sCi0Je0FDUElfUlNEX1VJTlQxNiwgQUNQSV9SU0RfT0ZGU0VUKGFkZHJlc3MxNi5taW5pbXVtKSwgIkFkZHJlc3MgTWluaW11bSIsCi0JIE5VTEx9LAotCXtBQ1BJX1JTRF9VSU5UMTYsIEFDUElfUlNEX09GRlNFVChhZGRyZXNzMTYubWF4aW11bSksICJBZGRyZXNzIE1heGltdW0iLAotCSBOVUxMfSwKLQl7QUNQSV9SU0RfVUlOVDE2LCBBQ1BJX1JTRF9PRkZTRVQoYWRkcmVzczE2LnRyYW5zbGF0aW9uX29mZnNldCksCisJe0FDUElfUlNEX1VJTlQxNiwgQUNQSV9SU0RfT0ZGU0VUKGFkZHJlc3MxNi5hZGRyZXNzLmdyYW51bGFyaXR5KSwKKwkgIkdyYW51bGFyaXR5IiwgTlVMTH0sCisJe0FDUElfUlNEX1VJTlQxNiwgQUNQSV9SU0RfT0ZGU0VUKGFkZHJlc3MxNi5hZGRyZXNzLm1pbmltdW0pLAorCSAiQWRkcmVzcyBNaW5pbXVtIiwgTlVMTH0sCisJe0FDUElfUlNEX1VJTlQxNiwgQUNQSV9SU0RfT0ZGU0VUKGFkZHJlc3MxNi5hZGRyZXNzLm1heGltdW0pLAorCSAiQWRkcmVzcyBNYXhpbXVtIiwgTlVMTH0sCisJe0FDUElfUlNEX1VJTlQxNiwgQUNQSV9SU0RfT0ZGU0VUKGFkZHJlc3MxNi5hZGRyZXNzLnRyYW5zbGF0aW9uX29mZnNldCksCiAJICJUcmFuc2xhdGlvbiBPZmZzZXQiLCBOVUxMfSwKLQl7QUNQSV9SU0RfVUlOVDE2LCBBQ1BJX1JTRF9PRkZTRVQoYWRkcmVzczE2LmFkZHJlc3NfbGVuZ3RoKSwKKwl7QUNQSV9SU0RfVUlOVDE2LCBBQ1BJX1JTRF9PRkZTRVQoYWRkcmVzczE2LmFkZHJlc3MuYWRkcmVzc19sZW5ndGgpLAogCSAiQWRkcmVzcyBMZW5ndGgiLCBOVUxMfSwKIAl7QUNQSV9SU0RfU09VUkNFLCBBQ1BJX1JTRF9PRkZTRVQoYWRkcmVzczE2LnJlc291cmNlX3NvdXJjZSksIE5VTEwsIE5VTEx9CiB9OwpAQCAtMjAwLDE1ICsyMDAsMTUgQEAKIAl7QUNQSV9SU0RfVElUTEUsIEFDUElfUlNEX1RBQkxFX1NJWkUoYWNwaV9yc19kdW1wX2FkZHJlc3MzMiksCiAJICIzMi1CaXQgRFdPUkQgQWRkcmVzcyBTcGFjZSIsIE5VTEx9LAogCXtBQ1BJX1JTRF9BRERSRVNTLCAwLCBOVUxMLCBOVUxMfSwKLQl7QUNQSV9SU0RfVUlOVDMyLCBBQ1BJX1JTRF9PRkZTRVQoYWRkcmVzczMyLmdyYW51bGFyaXR5KSwgIkdyYW51bGFyaXR5IiwKLQkgTlVMTH0sCi0Je0FDUElfUlNEX1VJTlQzMiwgQUNQSV9SU0RfT0ZGU0VUKGFkZHJlc3MzMi5taW5pbXVtKSwgIkFkZHJlc3MgTWluaW11bSIsCi0JIE5VTEx9LAotCXtBQ1BJX1JTRF9VSU5UMzIsIEFDUElfUlNEX09GRlNFVChhZGRyZXNzMzIubWF4aW11bSksICJBZGRyZXNzIE1heGltdW0iLAotCSBOVUxMfSwKLQl7QUNQSV9SU0RfVUlOVDMyLCBBQ1BJX1JTRF9PRkZTRVQoYWRkcmVzczMyLnRyYW5zbGF0aW9uX29mZnNldCksCisJe0FDUElfUlNEX1VJTlQzMiwgQUNQSV9SU0RfT0ZGU0VUKGFkZHJlc3MzMi5hZGRyZXNzLmdyYW51bGFyaXR5KSwKKwkgIkdyYW51bGFyaXR5IiwgTlVMTH0sCisJe0FDUElfUlNEX1VJTlQzMiwgQUNQSV9SU0RfT0ZGU0VUKGFkZHJlc3MzMi5hZGRyZXNzLm1pbmltdW0pLAorCSAiQWRkcmVzcyBNaW5pbXVtIiwgTlVMTH0sCisJe0FDUElfUlNEX1VJTlQzMiwgQUNQSV9SU0RfT0ZGU0VUKGFkZHJlc3MzMi5hZGRyZXNzLm1heGltdW0pLAorCSAiQWRkcmVzcyBNYXhpbXVtIiwgTlVMTH0sCisJe0FDUElfUlNEX1VJTlQzMiwgQUNQSV9SU0RfT0ZGU0VUKGFkZHJlc3MzMi5hZGRyZXNzLnRyYW5zbGF0aW9uX29mZnNldCksCiAJICJUcmFuc2xhdGlvbiBPZmZzZXQiLCBOVUxMfSwKLQl7QUNQSV9SU0RfVUlOVDMyLCBBQ1BJX1JTRF9PRkZTRVQoYWRkcmVzczMyLmFkZHJlc3NfbGVuZ3RoKSwKKwl7QUNQSV9SU0RfVUlOVDMyLCBBQ1BJX1JTRF9PRkZTRVQoYWRkcmVzczMyLmFkZHJlc3MuYWRkcmVzc19sZW5ndGgpLAogCSAiQWRkcmVzcyBMZW5ndGgiLCBOVUxMfSwKIAl7QUNQSV9SU0RfU09VUkNFLCBBQ1BJX1JTRF9PRkZTRVQoYWRkcmVzczMyLnJlc291cmNlX3NvdXJjZSksIE5VTEwsIE5VTEx9CiB9OwpAQCAtMjE3LDE1ICsyMTcsMTUgQEAKIAl7QUNQSV9SU0RfVElUTEUsIEFDUElfUlNEX1RBQkxFX1NJWkUoYWNwaV9yc19kdW1wX2FkZHJlc3M2NCksCiAJICI2NC1CaXQgUVdPUkQgQWRkcmVzcyBTcGFjZSIsIE5VTEx9LAogCXtBQ1BJX1JTRF9BRERSRVNTLCAwLCBOVUxMLCBOVUxMfSwKLQl7QUNQSV9SU0RfVUlOVDY0LCBBQ1BJX1JTRF9PRkZTRVQoYWRkcmVzczY0LmdyYW51bGFyaXR5KSwgIkdyYW51bGFyaXR5IiwKLQkgTlVMTH0sCi0Je0FDUElfUlNEX1VJTlQ2NCwgQUNQSV9SU0RfT0ZGU0VUKGFkZHJlc3M2NC5taW5pbXVtKSwgIkFkZHJlc3MgTWluaW11bSIsCi0JIE5VTEx9LAotCXtBQ1BJX1JTRF9VSU5UNjQsIEFDUElfUlNEX09GRlNFVChhZGRyZXNzNjQubWF4aW11bSksICJBZGRyZXNzIE1heGltdW0iLAotCSBOVUxMfSwKLQl7QUNQSV9SU0RfVUlOVDY0LCBBQ1BJX1JTRF9PRkZTRVQoYWRkcmVzczY0LnRyYW5zbGF0aW9uX29mZnNldCksCisJe0FDUElfUlNEX1VJTlQ2NCwgQUNQSV9SU0RfT0ZGU0VUKGFkZHJlc3M2NC5hZGRyZXNzLmdyYW51bGFyaXR5KSwKKwkgIkdyYW51bGFyaXR5IiwgTlVMTH0sCisJe0FDUElfUlNEX1VJTlQ2NCwgQUNQSV9SU0RfT0ZGU0VUKGFkZHJlc3M2NC5hZGRyZXNzLm1pbmltdW0pLAorCSAiQWRkcmVzcyBNaW5pbXVtIiwgTlVMTH0sCisJe0FDUElfUlNEX1VJTlQ2NCwgQUNQSV9SU0RfT0ZGU0VUKGFkZHJlc3M2NC5hZGRyZXNzLm1heGltdW0pLAorCSAiQWRkcmVzcyBNYXhpbXVtIiwgTlVMTH0sCisJe0FDUElfUlNEX1VJTlQ2NCwgQUNQSV9SU0RfT0ZGU0VUKGFkZHJlc3M2NC5hZGRyZXNzLnRyYW5zbGF0aW9uX29mZnNldCksCiAJICJUcmFuc2xhdGlvbiBPZmZzZXQiLCBOVUxMfSwKLQl7QUNQSV9SU0RfVUlOVDY0LCBBQ1BJX1JTRF9PRkZTRVQoYWRkcmVzczY0LmFkZHJlc3NfbGVuZ3RoKSwKKwl7QUNQSV9SU0RfVUlOVDY0LCBBQ1BJX1JTRF9PRkZTRVQoYWRkcmVzczY0LmFkZHJlc3MuYWRkcmVzc19sZW5ndGgpLAogCSAiQWRkcmVzcyBMZW5ndGgiLCBOVUxMfSwKIAl7QUNQSV9SU0RfU09VUkNFLCBBQ1BJX1JTRF9PRkZTRVQoYWRkcmVzczY0LnJlc291cmNlX3NvdXJjZSksIE5VTEwsIE5VTEx9CiB9OwpAQCAtMjM0LDE1ICsyMzQsMTYgQEAKIAl7QUNQSV9SU0RfVElUTEUsIEFDUElfUlNEX1RBQkxFX1NJWkUoYWNwaV9yc19kdW1wX2V4dF9hZGRyZXNzNjQpLAogCSAiNjQtQml0IEV4dGVuZGVkIEFkZHJlc3MgU3BhY2UiLCBOVUxMfSwKIAl7QUNQSV9SU0RfQUREUkVTUywgMCwgTlVMTCwgTlVMTH0sCi0Je0FDUElfUlNEX1VJTlQ2NCwgQUNQSV9SU0RfT0ZGU0VUKGV4dF9hZGRyZXNzNjQuZ3JhbnVsYXJpdHkpLAorCXtBQ1BJX1JTRF9VSU5UNjQsIEFDUElfUlNEX09GRlNFVChleHRfYWRkcmVzczY0LmFkZHJlc3MuZ3JhbnVsYXJpdHkpLAogCSAiR3JhbnVsYXJpdHkiLCBOVUxMfSwKLQl7QUNQSV9SU0RfVUlOVDY0LCBBQ1BJX1JTRF9PRkZTRVQoZXh0X2FkZHJlc3M2NC5taW5pbXVtKSwKKwl7QUNQSV9SU0RfVUlOVDY0LCBBQ1BJX1JTRF9PRkZTRVQoZXh0X2FkZHJlc3M2NC5hZGRyZXNzLm1pbmltdW0pLAogCSAiQWRkcmVzcyBNaW5pbXVtIiwgTlVMTH0sCi0Je0FDUElfUlNEX1VJTlQ2NCwgQUNQSV9SU0RfT0ZGU0VUKGV4dF9hZGRyZXNzNjQubWF4aW11bSksCisJe0FDUElfUlNEX1VJTlQ2NCwgQUNQSV9SU0RfT0ZGU0VUKGV4dF9hZGRyZXNzNjQuYWRkcmVzcy5tYXhpbXVtKSwKIAkgIkFkZHJlc3MgTWF4aW11bSIsIE5VTEx9LAotCXtBQ1BJX1JTRF9VSU5UNjQsIEFDUElfUlNEX09GRlNFVChleHRfYWRkcmVzczY0LnRyYW5zbGF0aW9uX29mZnNldCksCisJe0FDUElfUlNEX1VJTlQ2NCwKKwkgQUNQSV9SU0RfT0ZGU0VUKGV4dF9hZGRyZXNzNjQuYWRkcmVzcy50cmFuc2xhdGlvbl9vZmZzZXQpLAogCSAiVHJhbnNsYXRpb24gT2Zmc2V0IiwgTlVMTH0sCi0Je0FDUElfUlNEX1VJTlQ2NCwgQUNQSV9SU0RfT0ZGU0VUKGV4dF9hZGRyZXNzNjQuYWRkcmVzc19sZW5ndGgpLAorCXtBQ1BJX1JTRF9VSU5UNjQsIEFDUElfUlNEX09GRlNFVChleHRfYWRkcmVzczY0LmFkZHJlc3MuYWRkcmVzc19sZW5ndGgpLAogCSAiQWRkcmVzcyBMZW5ndGgiLCBOVUxMfSwKIAl7QUNQSV9SU0RfVUlOVDY0LCBBQ1BJX1JTRF9PRkZTRVQoZXh0X2FkZHJlc3M2NC50eXBlX3NwZWNpZmljKSwKIAkgIlR5cGUtU3BlY2lmaWMgQXR0cmlidXRlIiwgTlVMTH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNpbmZvLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzaW5mby5jCmluZGV4IDlkM2Y4YTkuLmVkZWNmYzYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNpbmZvLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9yc2luZm8uYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzaW8uYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNpby5jCmluZGV4IDE5ZDY0ODcuLjVhZGJhMDEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNpby5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNpby5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNpcnEuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNpcnEuYwppbmRleCAzNDYxZjdkLi4wN2NmYTcwIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzaXJxLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9yc2lycS5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNsaXN0LmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzbGlzdC5jCmluZGV4IDc3MjkxMjkuLjUwZDViZTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNsaXN0LmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9yc2xpc3QuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzbWVtb3J5LmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzbWVtb3J5LmMKaW5kZXggZWFiNDQ4My4uYzZiODA4NiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9yc21lbW9yeS5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNtZW1vcnkuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzbWlzYy5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9yc21pc2MuYwppbmRleCA0MWVlYTRiLi4xZmU0OWQyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzbWlzYy5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNtaXNjLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9yc3NlcmlhbC5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9yc3NlcmlhbC5jCmluZGV4IDllODQwNzIuLjRjOGM2ZmUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNzZXJpYWwuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3Jzc2VyaWFsLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9yc3V0aWxzLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzdXRpbHMuYwppbmRleCA4OTdhNWNlLi5lY2UzY2Q2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzdXRpbHMuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzdXRpbHMuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzeGZhY2UuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnN4ZmFjZS5jCmluZGV4IDg3N2FiOTIuLjhlNjI3NmRmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzeGZhY2UuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzeGZhY2UuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CkBAIC02MCwxMSArNjAsMTEgQEAKIAlBQ1BJX0NPUFlfRklFTEQob3V0LCBpbiwgbWluX2FkZHJlc3NfZml4ZWQpOyAgICAgICAgIFwKIAlBQ1BJX0NPUFlfRklFTEQob3V0LCBpbiwgbWF4X2FkZHJlc3NfZml4ZWQpOyAgICAgICAgIFwKIAlBQ1BJX0NPUFlfRklFTEQob3V0LCBpbiwgaW5mbyk7ICAgICAgICAgICAgICAgICAgICAgIFwKLQlBQ1BJX0NPUFlfRklFTEQob3V0LCBpbiwgZ3JhbnVsYXJpdHkpOyAgICAgICAgICAgICAgIFwKLQlBQ1BJX0NPUFlfRklFTEQob3V0LCBpbiwgbWluaW11bSk7ICAgICAgICAgICAgICAgICAgIFwKLQlBQ1BJX0NPUFlfRklFTEQob3V0LCBpbiwgbWF4aW11bSk7ICAgICAgICAgICAgICAgICAgIFwKLQlBQ1BJX0NPUFlfRklFTEQob3V0LCBpbiwgdHJhbnNsYXRpb25fb2Zmc2V0KTsgICAgICAgIFwKLQlBQ1BJX0NPUFlfRklFTEQob3V0LCBpbiwgYWRkcmVzc19sZW5ndGgpOyAgICAgICAgICAgIFwKKwlBQ1BJX0NPUFlfRklFTEQob3V0LCBpbiwgYWRkcmVzcy5ncmFudWxhcml0eSk7ICAgICAgIFwKKwlBQ1BJX0NPUFlfRklFTEQob3V0LCBpbiwgYWRkcmVzcy5taW5pbXVtKTsgICAgICAgICAgIFwKKwlBQ1BJX0NPUFlfRklFTEQob3V0LCBpbiwgYWRkcmVzcy5tYXhpbXVtKTsgICAgICAgICAgIFwKKwlBQ1BJX0NPUFlfRklFTEQob3V0LCBpbiwgYWRkcmVzcy50cmFuc2xhdGlvbl9vZmZzZXQpOyBcCisJQUNQSV9DT1BZX0ZJRUxEKG91dCwgaW4sIGFkZHJlc3MuYWRkcmVzc19sZW5ndGgpOyAgICBcCiAJQUNQSV9DT1BZX0ZJRUxEKG91dCwgaW4sIHJlc291cmNlX3NvdXJjZSk7CiAvKiBMb2NhbCBwcm90b3R5cGVzICovCiBzdGF0aWMgYWNwaV9zdGF0dXMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdGJkYXRhLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3RiZGF0YS5jCmluZGV4IGY0OTljMTAuLjZhMTQ0OTUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdGJkYXRhLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS90YmRhdGEuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdGJmYWR0LmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3RiZmFkdC5jCmluZGV4IDQxNTE5YTkuLjdkMjQ4NjAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdGJmYWR0LmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS90YmZhZHQuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdGJmaW5kLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3RiZmluZC5jCmluZGV4IGNiOTQ3NzAuLjBiODc5ZmMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdGJmaW5kLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS90YmZpbmQuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdGJpbnN0YWwuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdGJpbnN0YWwuYwppbmRleCA3NTViOTBjLi45YmFkNDVlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3RiaW5zdGFsLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS90Ymluc3RhbC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS90YnByaW50LmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3RicHJpbnQuYwppbmRleCBkZjNiYjIwLi5lZjE2YzA2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3RicHJpbnQuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3RicHJpbnQuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdGJ1dGlscy5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS90YnV0aWxzLmMKaW5kZXggNmIxY2E5OS4uNjU1OWE1OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS90YnV0aWxzLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS90YnV0aWxzLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3RieGZhY2UuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdGJ4ZmFjZS5jCmluZGV4IDY0ODJiMGQuLjYwZTk0ZjggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdGJ4ZmFjZS5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdGJ4ZmFjZS5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApAQCAtMjY1LDQ1ICsyNjUsNiBAQAogCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogICoKLSAqIEZVTkNUSU9OOiAgICBhY3BpX3VubG9hZF90YWJsZV9pZAotICoKLSAqIFBBUkFNRVRFUlM6ICBpZCAgICAgICAgICAgIC0gT3duZXIgSUQgb2YgdGhlIHRhYmxlIHRvIGJlIHJlbW92ZWQuCi0gKgotICogUkVUVVJOOiAgICAgIFN0YXR1cwotICoKLSAqIERFU0NSSVBUSU9OOiBUaGlzIHJvdXRpbmUgaXMgdXNlZCB0byBmb3JjZSB0aGUgdW5sb2FkIG9mIGEgdGFibGUgKGJ5IGlkKQotICoKLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1hY3BpX3N0YXR1cyBhY3BpX3VubG9hZF90YWJsZV9pZChhY3BpX293bmVyX2lkIGlkKQotewotCWludCBpOwotCWFjcGlfc3RhdHVzIHN0YXR1cyA9IEFFX05PVF9FWElTVDsKLQotCUFDUElfRlVOQ1RJT05fVFJBQ0UoYWNwaV91bmxvYWRfdGFibGVfaWQpOwotCi0JLyogRmluZCB0YWJsZSBpbiB0aGUgZ2xvYmFsIHRhYmxlIGxpc3QgKi8KLQlmb3IgKGkgPSAwOyBpIDwgYWNwaV9nYmxfcm9vdF90YWJsZV9saXN0LmN1cnJlbnRfdGFibGVfY291bnQ7ICsraSkgewotCQlpZiAoaWQgIT0gYWNwaV9nYmxfcm9vdF90YWJsZV9saXN0LnRhYmxlc1tpXS5vd25lcl9pZCkgewotCQkJY29udGludWU7Ci0JCX0KLQkJLyoKLQkJICogRGVsZXRlIGFsbCBuYW1lc3BhY2Ugb2JqZWN0cyBvd25lZCBieSB0aGlzIHRhYmxlLiBOb3RlIHRoYXQgdGhlc2UKLQkJICogb2JqZWN0cyBjYW4gYXBwZWFyIGFueXdoZXJlIGluIHRoZSBuYW1lc3BhY2UgYnkgdmlydHVlIG9mIHRoZSBBTUwKLQkJICogIlNjb3BlIiBvcGVyYXRvci4gVGh1cywgd2UgbmVlZCB0byB0cmFjayBvd25lcnNoaXAgYnkgYW4gSUQsIG5vdAotCQkgKiBzaW1wbHkgYSBwb3NpdGlvbiB3aXRoaW4gdGhlIGhpZXJhcmNoeQotCQkgKi8KLQkJYWNwaV90Yl9kZWxldGVfbmFtZXNwYWNlX2J5X293bmVyKGkpOwotCQlzdGF0dXMgPSBhY3BpX3RiX3JlbGVhc2Vfb3duZXJfaWQoaSk7Ci0JCWFjcGlfdGJfc2V0X3RhYmxlX2xvYWRlZF9mbGFnKGksIEZBTFNFKTsKLQkJYnJlYWs7Ci0JfQotCXJldHVybl9BQ1BJX1NUQVRVUyhzdGF0dXMpOwotfQotCi1BQ1BJX0VYUE9SVF9TWU1CT0woYWNwaV91bmxvYWRfdGFibGVfaWQpCi0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKgogICogRlVOQ1RJT046ICAgIGFjcGlfZ2V0X3RhYmxlX3dpdGhfc2l6ZQogICoKICAqIFBBUkFNRVRFUlM6ICBzaWduYXR1cmUgICAgICAgICAgIC0gQUNQSSBzaWduYXR1cmUgb2YgbmVlZGVkIHRhYmxlCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3RieGZsb2FkLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3RieGZsb2FkLmMKaW5kZXggYWI1MzA4Yi4uYWFkYjMwMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS90YnhmbG9hZC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdGJ4ZmxvYWQuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdGJ4ZnJvb3QuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdGJ4ZnJvb3QuYwppbmRleCA0M2E1NGFmLi5lYWM1MmNmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3RieGZyb290LmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS90Ynhmcm9vdC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS91dGFkZHJlc3MuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRhZGRyZXNzLmMKaW5kZXggYTFhY2VjOS4uMTI3OWY1MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS91dGFkZHJlc3MuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0YWRkcmVzcy5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS91dGFsbG9jLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0YWxsb2MuYwppbmRleCBlZmFjODNjLi42MWQ4ZjZkIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0YWxsb2MuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0YWxsb2MuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRidWZmZXIuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRidWZmZXIuYwppbmRleCAwMzhlYTg4Li4yNDJiZDA3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0YnVmZmVyLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dGJ1ZmZlci5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS91dGNhY2hlLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0Y2FjaGUuYwppbmRleCA3OGZkZTBhLi5lYWNjNWVlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0Y2FjaGUuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0Y2FjaGUuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRjb3B5LmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0Y29weS5jCmluZGV4IGZmNjAxYzAuLmMzN2VjNTAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRjb3B5LmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dGNvcHkuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRkZWJ1Zy5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dGRlYnVnLmMKaW5kZXggZTUxNjI1NC4uNTcwNzhlMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS91dGRlYnVnLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dGRlYnVnLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0ZGVjb2RlLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0ZGVjb2RlLmMKaW5kZXggNDBlOTIzZS4uOTg4ZTIzYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS91dGRlY29kZS5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRkZWNvZGUuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRkZWxldGUuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRkZWxldGUuYwppbmRleCBhMzUxNmRlLi43MWZjZTM4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0ZGVsZXRlLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dGRlbGV0ZS5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRlcnJvci5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dGVycm9yLmMKaW5kZXggOGU1NDRkNC4uOWVmODBmMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS91dGVycm9yLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dGVycm9yLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS91dGV2YWwuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRldmFsLmMKaW5kZXggOGZlZDE0OC4uNmM3MzhmYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS91dGV2YWwuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0ZXZhbC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS91dGV4Y2VwLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0ZXhjZXAuYwppbmRleCAwNDAzZGNhLi43NDNhMGFlOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS91dGV4Y2VwLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dGV4Y2VwLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS91dGZpbGVpby5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dGZpbGVpby5jCmluZGV4IDRlMjYzYTguLjdlMTE2OGIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRmaWxlaW8uYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0ZmlsZWlvLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS91dGdsb2JhbC5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dGdsb2JhbC5jCmluZGV4IDc3Y2VhYzcuLjVlOGRmOTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRnbG9iYWwuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0Z2xvYmFsLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0aGV4LmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0aGV4LmMKaW5kZXggOWFmYTk0NC4uYWE0NDgyNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS91dGhleC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRoZXguYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRpZHMuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRpZHMuYwppbmRleCA0YjEyODgwLi4yNzQzMWNmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0aWRzLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dGlkcy5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS91dGluaXQuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRpbml0LmMKaW5kZXggNzcxMjBlYy4uZTQwMmUwNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS91dGluaXQuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0aW5pdC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS91dGxvY2suYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRsb2NrLmMKaW5kZXggZGM2ZTk2NS4uMDg5Zjc4YiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS91dGxvY2suYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0bG9jay5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS91dG1hdGguYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRtYXRoLmMKaW5kZXggZDQ0ZGVlNi4uZjlmZjEwMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS91dG1hdGguYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0bWF0aC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRtaXNjLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0bWlzYy5jCmluZGV4IDJlMmJiMTQuLjU2YmJhY2Q1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0bWlzYy5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRtaXNjLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS91dG11dGV4LmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0bXV0ZXguYwppbmRleCA4MjcxN2ZmLi4zN2I4YjU4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0bXV0ZXguYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0bXV0ZXguYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0b2JqZWN0LmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0b2JqZWN0LmMKaW5kZXggZGZhOTAwOWIuLjdkODNlZmUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRvYmplY3QuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0b2JqZWN0LmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0b3NpLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0b3NpLmMKaW5kZXggNjg1NzY2Zi4uNTc0Y2QzMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS91dG9zaS5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRvc2kuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRvd25lcmlkLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0b3duZXJpZC5jCmluZGV4IDM2YmVjNTcuLjI5NTkyMTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRvd25lcmlkLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dG93bmVyaWQuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0cHJlZGVmLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0cHJlZGVmLmMKaW5kZXggZGIzMGNhZi4uMjllNDQ5OSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS91dHByZWRlZi5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRwcmVkZWYuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRwcmludC5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dHByaW50LmMKaW5kZXggMGNlM2Y1YS4uODJjYTkxNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS91dHByaW50LmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dHByaW50LmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0cmVzcmMuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRyZXNyYy5jCmluZGV4IGJjMWZmODIuLmIzNTA1ZGIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRyZXNyYy5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRyZXNyYy5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRzdGF0ZS5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dHN0YXRlLmMKaW5kZXggMWNjOTdhNy4uODI3NGNjMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS91dHN0YXRlLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dHN0YXRlLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS91dHN0cmluZy5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dHN0cmluZy5jCmluZGV4IDZkYzU0YjMuLjgzYjZjNTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRzdHJpbmcuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0c3RyaW5nLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS91dHRyYWNrLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0dHJhY2suYwppbmRleCA3ZDBlZTk2Li4xMzBkZDlmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0dHJhY2suYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0dHJhY2suYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXR1dWlkLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0dXVpZC5jCmluZGV4IDRkYzMzMTMuLmM2MTQ5YTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXR1dWlkLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dHV1aWQuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXR4ZmFjZS5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dHhmYWNlLmMKaW5kZXggNDljODczYy4uMDkyOTE4NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS91dHhmYWNlLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dHhmYWNlLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0eGZlcnJvci5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dHhmZXJyb3IuYwppbmRleCA4OGVmNzdmLi4zMDZlNzg1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0eGZlcnJvci5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXR4ZmVycm9yLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS91dHhmaW5pdC5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dHhmaW5pdC5jCmluZGV4IGIxZmQ2ODguLjA4M2E3NjggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXR4ZmluaXQuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0eGZpbml0LmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0eGZtdXRleC5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dHhmbXV0ZXguYwppbmRleCAyYTBmOWUwLi5mMjYwNmFmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0eGZtdXRleC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXR4Zm11dGV4LmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2RldmljZV9wbS5jIGIvZHJpdmVycy9hY3BpL2RldmljZV9wbS5jCmluZGV4IGMwZDQ0ZDMuLjczNWRiMTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9kZXZpY2VfcG0uYworKysgYi9kcml2ZXJzL2FjcGkvZGV2aWNlX3BtLmMKQEAgLTEwMjcsNyArMTAyNyw2IEBACiAKIHN0YXRpYyBzdHJ1Y3QgZGV2X3BtX2RvbWFpbiBhY3BpX2dlbmVyYWxfcG1fZG9tYWluID0gewogCS5vcHMgPSB7Ci0jaWZkZWYgQ09ORklHX1BNCiAJCS5ydW50aW1lX3N1c3BlbmQgPSBhY3BpX3N1YnN5c19ydW50aW1lX3N1c3BlbmQsCiAJCS5ydW50aW1lX3Jlc3VtZSA9IGFjcGlfc3Vic3lzX3J1bnRpbWVfcmVzdW1lLAogI2lmZGVmIENPTkZJR19QTV9TTEVFUApAQCAtMTA0MSw3ICsxMDQwLDYgQEAKIAkJLnBvd2Vyb2ZmX2xhdGUgPSBhY3BpX3N1YnN5c19zdXNwZW5kX2xhdGUsCiAJCS5yZXN0b3JlX2Vhcmx5ID0gYWNwaV9zdWJzeXNfcmVzdW1lX2Vhcmx5LAogI2VuZGlmCi0jZW5kaWYKIAl9LAogfTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2VjLmMgYi9kcml2ZXJzL2FjcGkvZWMuYwppbmRleCAxYjU4NTNmLi4xNGQwYzg5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvZWMuYworKysgYi9kcml2ZXJzL2FjcGkvZWMuYwpAQCAtMSw4ICsxLDggQEAKIC8qCi0gKiAgZWMuYyAtIEFDUEkgRW1iZWRkZWQgQ29udHJvbGxlciBEcml2ZXIgKHYyLjIpCisgKiAgZWMuYyAtIEFDUEkgRW1iZWRkZWQgQ29udHJvbGxlciBEcml2ZXIgKHYzKQogICoKLSAqICBDb3B5cmlnaHQgKEMpIDIwMDEtMjAxNCBJbnRlbCBDb3Jwb3JhdGlvbgotICogICAgQXV0aG9yOiAyMDE0ICAgICAgIEx2IFpoZW5nIDxsdi56aGVuZ0BpbnRlbC5jb20+CisgKiAgQ29weXJpZ2h0IChDKSAyMDAxLTIwMTUgSW50ZWwgQ29ycG9yYXRpb24KKyAqICAgIEF1dGhvcjogMjAxNCwgMjAxNSBMdiBaaGVuZyA8bHYuemhlbmdAaW50ZWwuY29tPgogICogICAgICAgICAgICAyMDA2LCAyMDA3IEFsZXhleSBTdGFyaWtvdnNraXkgPGFsZXhleS55LnN0YXJpa292c2tpeUBpbnRlbC5jb20+CiAgKiAgICAgICAgICAgIDIwMDYgICAgICAgRGVuaXMgU2FkeWtvdiA8ZGVuaXMubS5zYWR5a292QGludGVsLmNvbT4KICAqICAgICAgICAgICAgMjAwNCAgICAgICBMdW1pbmcgWXUgPGx1bWluZy55dUBpbnRlbC5jb20+CkBAIC0zMSw2ICszMSw3IEBACiAKIC8qIFVuY29tbWVudCBuZXh0IGxpbmUgdG8gZ2V0IHZlcmJvc2UgcHJpbnRvdXQgKi8KIC8qICNkZWZpbmUgREVCVUcgKi8KKyNkZWZpbmUgREVCVUdfUkVGIDAKICNkZWZpbmUgcHJfZm10KGZtdCkgIkFDUEkgOiBFQzogIiBmbXQKIAogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgpAQCAtNzEsMjAgKzcyLDMyIEBACiAjZGVmaW5lIEFDUElfRUNfREVMQVkJCTUwMAkvKiBXYWl0IDUwMG1zIG1heC4gZHVyaW5nIEVDIG9wcyAqLwogI2RlZmluZSBBQ1BJX0VDX1VERUxBWV9HTEsJMTAwMAkvKiBXYWl0IDFtcyBtYXguIHRvIGdldCBnbG9iYWwgbG9jayAqLwogI2RlZmluZSBBQ1BJX0VDX01TSV9VREVMQVkJNTUwCS8qIFdhaXQgNTUwdXMgZm9yIE1TSSBFQyAqLworI2RlZmluZSBBQ1BJX0VDX1VERUxBWV9QT0xMCTEwMDAJLyogV2FpdCAxbXMgZm9yIEVDIHRyYW5zYWN0aW9uIHBvbGxpbmcgKi8KICNkZWZpbmUgQUNQSV9FQ19DTEVBUl9NQVgJMTAwCS8qIE1heGltdW0gbnVtYmVyIG9mIGV2ZW50cyB0byBxdWVyeQogCQkJCQkgKiB3aGVuIHRyeWluZyB0byBjbGVhciB0aGUgRUMgKi8KIAogZW51bSB7Ci0JRUNfRkxBR1NfUVVFUllfUEVORElORywJCS8qIFF1ZXJ5IGlzIHBlbmRpbmcgKi8KLQlFQ19GTEFHU19HUEVfU1RPUk0sCQkvKiBHUEUgc3Rvcm0gZGV0ZWN0ZWQgKi8KKwlFQ19GTEFHU19FVkVOVF9FTkFCTEVELAkJLyogRXZlbnQgaXMgZW5hYmxlZCAqLworCUVDX0ZMQUdTX0VWRU5UX1BFTkRJTkcsCQkvKiBFdmVudCBpcyBwZW5kaW5nICovCisJRUNfRkxBR1NfRVZFTlRfREVURUNURUQsCS8qIEV2ZW50IGlzIGRldGVjdGVkICovCiAJRUNfRkxBR1NfSEFORExFUlNfSU5TVEFMTEVELAkvKiBIYW5kbGVycyBmb3IgR1BFIGFuZAogCQkJCQkgKiBPcFJlZyBhcmUgaW5zdGFsbGVkICovCi0JRUNfRkxBR1NfQkxPQ0tFRCwJCS8qIFRyYW5zYWN0aW9ucyBhcmUgYmxvY2tlZCAqLworCUVDX0ZMQUdTX1NUQVJURUQsCQkvKiBEcml2ZXIgaXMgc3RhcnRlZCAqLworCUVDX0ZMQUdTX1NUT1BQRUQsCQkvKiBEcml2ZXIgaXMgc3RvcHBlZCAqLworCUVDX0ZMQUdTX0NPTU1BTkRfU1RPUk0sCQkvKiBHUEUgc3Rvcm1zIG9jY3VycmVkIHRvIHRoZQorCQkJCQkgKiBjdXJyZW50IGNvbW1hbmQgcHJvY2Vzc2luZyAqLwogfTsKIAogI2RlZmluZSBBQ1BJX0VDX0NPTU1BTkRfUE9MTAkJMHgwMSAvKiBBdmFpbGFibGUgZm9yIGNvbW1hbmQgYnl0ZSAqLwogI2RlZmluZSBBQ1BJX0VDX0NPTU1BTkRfQ09NUExFVEUJMHgwMiAvKiBDb21wbGV0ZWQgbGFzdCBieXRlICovCiAKKyNkZWZpbmUgZWNfZGVidWdfcmVmKGVjLCBmbXQsIC4uLikJCQkJCVwKKwlkbyB7CQkJCQkJCQlcCisJCWlmIChERUJVR19SRUYpCQkJCQkJXAorCQkJcHJfZGVidWcoIiVsdTogIiBmbXQsIGVjLT5yZWZlcmVuY2VfY291bnQsCVwKKwkJCQkgIyMgX19WQV9BUkdTX18pOwkJCVwKKwl9IHdoaWxlICgwKQorCiAvKiBlYy5jIGlzIGNvbXBpbGVkIGluIGFjcGkgbmFtZXNwYWNlIHNvIHRoaXMgc2hvd3MgdXAgYXMgYWNwaS5lY19kZWxheSBwYXJhbSAqLwogc3RhdGljIHVuc2lnbmVkIGludCBlY19kZWxheSBfX3JlYWRfbW9zdGx5ID0gQUNQSV9FQ19ERUxBWTsKIG1vZHVsZV9wYXJhbShlY19kZWxheSwgdWludCwgMDY0NCk7CkBAIC0xMDUsNiArMTE4LDcgQEAKIAlhY3BpX2hhbmRsZSBoYW5kbGU7CiAJdm9pZCAqZGF0YTsKIAl1OCBxdWVyeV9iaXQ7CisJc3RydWN0IGtyZWYga3JlZjsKIH07CiAKIHN0cnVjdCB0cmFuc2FjdGlvbiB7CkBAIC0xMTcsOCArMTMxLDEyIEBACiAJdTggd2xlbjsKIAl1OCBybGVuOwogCXU4IGZsYWdzOworCXVuc2lnbmVkIGxvbmcgdGltZXN0YW1wOwogfTsKIAorc3RhdGljIGludCBhY3BpX2VjX3F1ZXJ5KHN0cnVjdCBhY3BpX2VjICplYywgdTggKmRhdGEpOworc3RhdGljIHZvaWQgYWR2YW5jZV90cmFuc2FjdGlvbihzdHJ1Y3QgYWNwaV9lYyAqZWMpOworCiBzdHJ1Y3QgYWNwaV9lYyAqYm9vdF9lYywgKmZpcnN0X2VjOwogRVhQT1JUX1NZTUJPTChmaXJzdF9lYyk7CiAKQEAgLTEyOSw3ICsxNDcsMjggQEAKIHN0YXRpYyBpbnQgRUNfRkxBR1NfUVVFUllfSEFORFNIQUtFOyAvKiBOZWVkcyBRUl9FQyBpc3N1ZWQgd2hlbiBTQ0lfRVZUIHNldCAqLwogCiAvKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotICogICAgICAgICAgICAgICAgICAgICAgICAgICBUcmFuc2FjdGlvbiBNYW5hZ2VtZW50CisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgIERldmljZSBGbGFncworICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KKworc3RhdGljIGJvb2wgYWNwaV9lY19zdGFydGVkKHN0cnVjdCBhY3BpX2VjICplYykKK3sKKwlyZXR1cm4gdGVzdF9iaXQoRUNfRkxBR1NfU1RBUlRFRCwgJmVjLT5mbGFncykgJiYKKwkgICAgICAgIXRlc3RfYml0KEVDX0ZMQUdTX1NUT1BQRUQsICZlYy0+ZmxhZ3MpOworfQorCitzdGF0aWMgYm9vbCBhY3BpX2VjX2ZsdXNoZWQoc3RydWN0IGFjcGlfZWMgKmVjKQoreworCXJldHVybiBlYy0+cmVmZXJlbmNlX2NvdW50ID09IDE7Cit9CisKK3N0YXRpYyBib29sIGFjcGlfZWNfaGFzX3BlbmRpbmdfZXZlbnQoc3RydWN0IGFjcGlfZWMgKmVjKQoreworCXJldHVybiB0ZXN0X2JpdChFQ19GTEFHU19FVkVOVF9ERVRFQ1RFRCwgJmVjLT5mbGFncykgfHwKKwkgICAgICAgdGVzdF9iaXQoRUNfRkxBR1NfRVZFTlRfUEVORElORywgJmVjLT5mbGFncyk7Cit9CisKKy8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgIEVDIFJlZ2lzdGVycwogICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KIAogc3RhdGljIGlubGluZSB1OCBhY3BpX2VjX3JlYWRfc3RhdHVzKHN0cnVjdCBhY3BpX2VjICplYykKQEAgLTE1MSw2ICsxOTAsNyBAQAogewogCXU4IHggPSBpbmIoZWMtPmRhdGFfYWRkcik7CiAKKwllYy0+Y3Vyci0+dGltZXN0YW1wID0gamlmZmllczsKIAlwcl9kZWJ1ZygiRUNfREFUQShSKSA9IDB4JTIuMnhcbiIsIHgpOwogCXJldHVybiB4OwogfQpAQCAtMTU5LDEyICsxOTksMTQgQEAKIHsKIAlwcl9kZWJ1ZygiRUNfU0MoVykgPSAweCUyLjJ4XG4iLCBjb21tYW5kKTsKIAlvdXRiKGNvbW1hbmQsIGVjLT5jb21tYW5kX2FkZHIpOworCWVjLT5jdXJyLT50aW1lc3RhbXAgPSBqaWZmaWVzOwogfQogCiBzdGF0aWMgaW5saW5lIHZvaWQgYWNwaV9lY193cml0ZV9kYXRhKHN0cnVjdCBhY3BpX2VjICplYywgdTggZGF0YSkKIHsKIAlwcl9kZWJ1ZygiRUNfREFUQShXKSA9IDB4JTIuMnhcbiIsIGRhdGEpOwogCW91dGIoZGF0YSwgZWMtPmRhdGFfYWRkcik7CisJZWMtPmN1cnItPnRpbWVzdGFtcCA9IGppZmZpZXM7CiB9CiAKICNpZmRlZiBERUJVRwpAQCAtMTg4LDYgKzIzMCwyMDMgQEAKICNkZWZpbmUgYWNwaV9lY19jbWRfc3RyaW5nKGNtZCkJCSJVTkRFRiIKICNlbmRpZgogCisvKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICogICAgICAgICAgICAgICAgICAgICAgICAgICBHUEUgUmVnaXN0ZXJzCisgKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLworCitzdGF0aWMgaW5saW5lIGJvb2wgYWNwaV9lY19pc19ncGVfcmFpc2VkKHN0cnVjdCBhY3BpX2VjICplYykKK3sKKwlhY3BpX2V2ZW50X3N0YXR1cyBncGVfc3RhdHVzID0gMDsKKworCSh2b2lkKWFjcGlfZ2V0X2dwZV9zdGF0dXMoTlVMTCwgZWMtPmdwZSwgJmdwZV9zdGF0dXMpOworCXJldHVybiAoZ3BlX3N0YXR1cyAmIEFDUElfRVZFTlRfRkxBR19TRVQpID8gdHJ1ZSA6IGZhbHNlOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgYWNwaV9lY19lbmFibGVfZ3BlKHN0cnVjdCBhY3BpX2VjICplYywgYm9vbCBvcGVuKQoreworCWlmIChvcGVuKQorCQlhY3BpX2VuYWJsZV9ncGUoTlVMTCwgZWMtPmdwZSk7CisJZWxzZSB7CisJCUJVR19PTihlYy0+cmVmZXJlbmNlX2NvdW50IDwgMSk7CisJCWFjcGlfc2V0X2dwZShOVUxMLCBlYy0+Z3BlLCBBQ1BJX0dQRV9FTkFCTEUpOworCX0KKwlpZiAoYWNwaV9lY19pc19ncGVfcmFpc2VkKGVjKSkgeworCQkvKgorCQkgKiBPbiBzb21lIHBsYXRmb3JtcywgRU49MSB3cml0ZXMgY2Fubm90IHRyaWdnZXIgR1BFLiBTbworCQkgKiBzb2Z0d2FyZSBuZWVkIHRvIG1hbnVhbGx5IHRyaWdnZXIgYSBwc2V1ZG8gR1BFIGV2ZW50IG9uCisJCSAqIEVOPTEgd3JpdGVzLgorCQkgKi8KKwkJcHJfZGVidWcoIioqKioqIFBvbGxpbmcgcXVpcmsgKioqKipcbiIpOworCQlhZHZhbmNlX3RyYW5zYWN0aW9uKGVjKTsKKwl9Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBhY3BpX2VjX2Rpc2FibGVfZ3BlKHN0cnVjdCBhY3BpX2VjICplYywgYm9vbCBjbG9zZSkKK3sKKwlpZiAoY2xvc2UpCisJCWFjcGlfZGlzYWJsZV9ncGUoTlVMTCwgZWMtPmdwZSk7CisJZWxzZSB7CisJCUJVR19PTihlYy0+cmVmZXJlbmNlX2NvdW50IDwgMSk7CisJCWFjcGlfc2V0X2dwZShOVUxMLCBlYy0+Z3BlLCBBQ1BJX0dQRV9ESVNBQkxFKTsKKwl9Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBhY3BpX2VjX2NsZWFyX2dwZShzdHJ1Y3QgYWNwaV9lYyAqZWMpCit7CisJLyoKKwkgKiBHUEUgU1RTIGlzIGEgVzFDIHJlZ2lzdGVyLCB3aGljaCBtZWFuczoKKwkgKiAxLiBTb2Z0d2FyZSBjYW4gY2xlYXIgaXQgd2l0aG91dCB3b3JyeWluZyBhYm91dCBjbGVhcmluZyBvdGhlcgorCSAqICAgIEdQRXMnIFNUUyBiaXRzIHdoZW4gdGhlIGhhcmR3YXJlIHNldHMgdGhlbSBpbiBwYXJhbGxlbC4KKwkgKiAyLiBBcyBsb25nIGFzIHNvZnR3YXJlIGNhbiBlbnN1cmUgb25seSBjbGVhcmluZyBpdCB3aGVuIGl0IGlzCisJICogICAgc2V0LCBoYXJkd2FyZSB3b24ndCBzZXQgaXQgaW4gcGFyYWxsZWwuCisJICogU28gc29mdHdhcmUgY2FuIGNsZWFyIEdQRSBpbiBhbnkgY29udGV4dHMuCisJICogV2FybmluZzogZG8gbm90IG1vdmUgdGhlIGNoZWNrIGludG8gYWR2YW5jZV90cmFuc2FjdGlvbigpIGFzIHRoZQorCSAqIEVDIGNvbW1hbmRzIHdpbGwgYmUgc2VudCB3aXRob3V0IEdQRSByYWlzZWQuCisJICovCisJaWYgKCFhY3BpX2VjX2lzX2dwZV9yYWlzZWQoZWMpKQorCQlyZXR1cm47CisJYWNwaV9jbGVhcl9ncGUoTlVMTCwgZWMtPmdwZSk7Cit9CisKKy8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgIFRyYW5zYWN0aW9uIE1hbmFnZW1lbnQKKyAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCisKK3N0YXRpYyB2b2lkIGFjcGlfZWNfc3VibWl0X3JlcXVlc3Qoc3RydWN0IGFjcGlfZWMgKmVjKQoreworCWVjLT5yZWZlcmVuY2VfY291bnQrKzsKKwlpZiAoZWMtPnJlZmVyZW5jZV9jb3VudCA9PSAxKQorCQlhY3BpX2VjX2VuYWJsZV9ncGUoZWMsIHRydWUpOworfQorCitzdGF0aWMgdm9pZCBhY3BpX2VjX2NvbXBsZXRlX3JlcXVlc3Qoc3RydWN0IGFjcGlfZWMgKmVjKQoreworCWJvb2wgZmx1c2hlZCA9IGZhbHNlOworCisJZWMtPnJlZmVyZW5jZV9jb3VudC0tOworCWlmIChlYy0+cmVmZXJlbmNlX2NvdW50ID09IDApCisJCWFjcGlfZWNfZGlzYWJsZV9ncGUoZWMsIHRydWUpOworCWZsdXNoZWQgPSBhY3BpX2VjX2ZsdXNoZWQoZWMpOworCWlmIChmbHVzaGVkKQorCQl3YWtlX3VwKCZlYy0+d2FpdCk7Cit9CisKK3N0YXRpYyB2b2lkIGFjcGlfZWNfc2V0X3N0b3JtKHN0cnVjdCBhY3BpX2VjICplYywgdTggZmxhZykKK3sKKwlpZiAoIXRlc3RfYml0KGZsYWcsICZlYy0+ZmxhZ3MpKSB7CisJCWFjcGlfZWNfZGlzYWJsZV9ncGUoZWMsIGZhbHNlKTsKKwkJcHJfZGVidWcoIisrKysrIFBvbGxpbmcgZW5hYmxlZCArKysrK1xuIik7CisJCXNldF9iaXQoZmxhZywgJmVjLT5mbGFncyk7CisJfQorfQorCitzdGF0aWMgdm9pZCBhY3BpX2VjX2NsZWFyX3N0b3JtKHN0cnVjdCBhY3BpX2VjICplYywgdTggZmxhZykKK3sKKwlpZiAodGVzdF9iaXQoZmxhZywgJmVjLT5mbGFncykpIHsKKwkJY2xlYXJfYml0KGZsYWcsICZlYy0+ZmxhZ3MpOworCQlhY3BpX2VjX2VuYWJsZV9ncGUoZWMsIGZhbHNlKTsKKwkJcHJfZGVidWcoIisrKysrIFBvbGxpbmcgZGlzYWJsZWQgKysrKytcbiIpOworCX0KK30KKworLyoKKyAqIGFjcGlfZWNfc3VibWl0X2ZsdXNoYWJsZV9yZXF1ZXN0KCkgLSBJbmNyZWFzZSB0aGUgcmVmZXJlbmNlIGNvdW50IHVubGVzcworICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRoZSBmbHVzaCBvcGVyYXRpb24gaXMgbm90IGluCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcHJvZ3Jlc3MKKyAqIEBlYzogdGhlIEVDIGRldmljZQorICogQGFsbG93X2V2ZW50OiB3aGV0aGVyIGV2ZW50IHNob3VsZCBiZSBoYW5kbGVkCisgKgorICogVGhpcyBmdW5jdGlvbiBtdXN0IGJlIHVzZWQgYmVmb3JlIHRha2luZyBhIG5ldyBhY3Rpb24gdGhhdCBzaG91bGQgaG9sZAorICogdGhlIHJlZmVyZW5jZSBjb3VudC4gIElmIHRoaXMgZnVuY3Rpb24gcmV0dXJucyBmYWxzZSwgdGhlbiB0aGUgYWN0aW9uCisgKiBtdXN0IGJlIGRpc2NhcmRlZCBvciBpdCB3aWxsIHByZXZlbnQgdGhlIGZsdXNoIG9wZXJhdGlvbiBmcm9tIGJlaW5nCisgKiBjb21wbGV0ZWQuCisgKgorICogRHVyaW5nIGZsdXNoaW5nLCBRUl9FQyBjb21tYW5kIG5lZWQgdG8gcGFzcyB0aGlzIGNoZWNrIHdoZW4gdGhlcmUgaXMgYQorICogcGVuZGluZyBldmVudCwgc28gdGhhdCB0aGUgcmVmZXJlbmNlIGNvdW50IGhlbGQgZm9yIHRoZSBwZW5kaW5nIGV2ZW50CisgKiBjYW4gYmUgZGVjcmVhc2VkIGJ5IHRoZSBjb21wbGV0aW9uIG9mIHRoZSBRUl9FQyBjb21tYW5kLgorICovCitzdGF0aWMgYm9vbCBhY3BpX2VjX3N1Ym1pdF9mbHVzaGFibGVfcmVxdWVzdChzdHJ1Y3QgYWNwaV9lYyAqZWMsCisJCQkJCSAgICAgYm9vbCBhbGxvd19ldmVudCkKK3sKKwlpZiAoIWFjcGlfZWNfc3RhcnRlZChlYykpIHsKKwkJaWYgKCFhbGxvd19ldmVudCB8fCAhYWNwaV9lY19oYXNfcGVuZGluZ19ldmVudChlYykpCisJCQlyZXR1cm4gZmFsc2U7CisJfQorCWFjcGlfZWNfc3VibWl0X3JlcXVlc3QoZWMpOworCXJldHVybiB0cnVlOworfQorCitzdGF0aWMgdm9pZCBhY3BpX2VjX3N1Ym1pdF9ldmVudChzdHJ1Y3QgYWNwaV9lYyAqZWMpCit7CisJaWYgKCF0ZXN0X2JpdChFQ19GTEFHU19FVkVOVF9ERVRFQ1RFRCwgJmVjLT5mbGFncykgfHwKKwkgICAgIXRlc3RfYml0KEVDX0ZMQUdTX0VWRU5UX0VOQUJMRUQsICZlYy0+ZmxhZ3MpKQorCQlyZXR1cm47CisJLyogSG9sZCByZWZlcmVuY2UgZm9yIHBlbmRpbmcgZXZlbnQgKi8KKwlpZiAoIWFjcGlfZWNfc3VibWl0X2ZsdXNoYWJsZV9yZXF1ZXN0KGVjLCB0cnVlKSkKKwkJcmV0dXJuOworCWVjX2RlYnVnX3JlZihlYywgIkluY3JlYXNlIGV2ZW50XG4iKTsKKwlpZiAoIXRlc3RfYW5kX3NldF9iaXQoRUNfRkxBR1NfRVZFTlRfUEVORElORywgJmVjLT5mbGFncykpIHsKKwkJcHJfZGVidWcoIioqKioqIEV2ZW50IHF1ZXJ5IHN0YXJ0ZWQgKioqKipcbiIpOworCQlzY2hlZHVsZV93b3JrKCZlYy0+d29yayk7CisJCXJldHVybjsKKwl9CisJYWNwaV9lY19jb21wbGV0ZV9yZXF1ZXN0KGVjKTsKKwllY19kZWJ1Z19yZWYoZWMsICJEZWNyZWFzZSBldmVudFxuIik7Cit9CisKK3N0YXRpYyB2b2lkIGFjcGlfZWNfY29tcGxldGVfZXZlbnQoc3RydWN0IGFjcGlfZWMgKmVjKQoreworCWlmIChlYy0+Y3Vyci0+Y29tbWFuZCA9PSBBQ1BJX0VDX0NPTU1BTkRfUVVFUlkpIHsKKwkJY2xlYXJfYml0KEVDX0ZMQUdTX0VWRU5UX1BFTkRJTkcsICZlYy0+ZmxhZ3MpOworCQlwcl9kZWJ1ZygiKioqKiogRXZlbnQgcXVlcnkgc3RvcHBlZCAqKioqKlxuIik7CisJCS8qIFVuaG9sZCByZWZlcmVuY2UgZm9yIHBlbmRpbmcgZXZlbnQgKi8KKwkJYWNwaV9lY19jb21wbGV0ZV9yZXF1ZXN0KGVjKTsKKwkJZWNfZGVidWdfcmVmKGVjLCAiRGVjcmVhc2UgZXZlbnRcbiIpOworCQkvKiBDaGVjayBpZiB0aGVyZSBpcyBhbm90aGVyIFNDSV9FVlQgZGV0ZWN0ZWQgKi8KKwkJYWNwaV9lY19zdWJtaXRfZXZlbnQoZWMpOworCX0KK30KKworc3RhdGljIHZvaWQgYWNwaV9lY19zdWJtaXRfZGV0ZWN0aW9uKHN0cnVjdCBhY3BpX2VjICplYykKK3sKKwkvKiBIb2xkIHJlZmVyZW5jZSBmb3IgcXVlcnkgc3VibWlzc2lvbiAqLworCWlmICghYWNwaV9lY19zdWJtaXRfZmx1c2hhYmxlX3JlcXVlc3QoZWMsIGZhbHNlKSkKKwkJcmV0dXJuOworCWVjX2RlYnVnX3JlZihlYywgIkluY3JlYXNlIHF1ZXJ5XG4iKTsKKwlpZiAoIXRlc3RfYW5kX3NldF9iaXQoRUNfRkxBR1NfRVZFTlRfREVURUNURUQsICZlYy0+ZmxhZ3MpKSB7CisJCXByX2RlYnVnKCIqKioqKiBFdmVudCBkZXRlY3Rpb24gYmxvY2tlZCAqKioqKlxuIik7CisJCWFjcGlfZWNfc3VibWl0X2V2ZW50KGVjKTsKKwkJcmV0dXJuOworCX0KKwlhY3BpX2VjX2NvbXBsZXRlX3JlcXVlc3QoZWMpOworCWVjX2RlYnVnX3JlZihlYywgIkRlY3JlYXNlIHF1ZXJ5XG4iKTsKK30KKworc3RhdGljIHZvaWQgYWNwaV9lY19jb21wbGV0ZV9kZXRlY3Rpb24oc3RydWN0IGFjcGlfZWMgKmVjKQoreworCWlmIChlYy0+Y3Vyci0+Y29tbWFuZCA9PSBBQ1BJX0VDX0NPTU1BTkRfUVVFUlkpIHsKKwkJY2xlYXJfYml0KEVDX0ZMQUdTX0VWRU5UX0RFVEVDVEVELCAmZWMtPmZsYWdzKTsKKwkJcHJfZGVidWcoIioqKioqIEV2ZW50IGRldGV0aW9uIHVuYmxvY2tlZCAqKioqKlxuIik7CisJCS8qIFVuaG9sZCByZWZlcmVuY2UgZm9yIHF1ZXJ5IHN1Ym1pc3Npb24gKi8KKwkJYWNwaV9lY19jb21wbGV0ZV9yZXF1ZXN0KGVjKTsKKwkJZWNfZGVidWdfcmVmKGVjLCAiRGVjcmVhc2UgcXVlcnlcbiIpOworCX0KK30KKworc3RhdGljIHZvaWQgYWNwaV9lY19lbmFibGVfZXZlbnQoc3RydWN0IGFjcGlfZWMgKmVjKQoreworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmZWMtPmxvY2ssIGZsYWdzKTsKKwlzZXRfYml0KEVDX0ZMQUdTX0VWRU5UX0VOQUJMRUQsICZlYy0+ZmxhZ3MpOworCS8qCisJICogQW4gZXZlbnQgbWF5IGJlIHBlbmRpbmcgZXZlbiB3aXRoIFNDSV9FVlQ9MCwgc28gUVJfRUMgc2hvdWxkCisJICogYWx3YXlzIGJlIGlzc3VlZCByaWdodCBhZnRlciBzdGFydGVkLgorCSAqLworCWFjcGlfZWNfc3VibWl0X2RldGVjdGlvbihlYyk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZWMtPmxvY2ssIGZsYWdzKTsKK30KKwogc3RhdGljIGludCBlY190cmFuc2FjdGlvbl9jb21wbGV0ZWQoc3RydWN0IGFjcGlfZWMgKmVjKQogewogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CkBAIC0yMDAsNyArNDM5LDcgQEAKIAlyZXR1cm4gcmV0OwogfQogCi1zdGF0aWMgYm9vbCBhZHZhbmNlX3RyYW5zYWN0aW9uKHN0cnVjdCBhY3BpX2VjICplYykKK3N0YXRpYyB2b2lkIGFkdmFuY2VfdHJhbnNhY3Rpb24oc3RydWN0IGFjcGlfZWMgKmVjKQogewogCXN0cnVjdCB0cmFuc2FjdGlvbiAqdDsKIAl1OCBzdGF0dXM7CkBAIC0yMDgsNiArNDQ3LDEyIEBACiAKIAlwcl9kZWJ1ZygiPT09PT0gJXMgKCVkKSA9PT09PVxuIiwKIAkJIGluX2ludGVycnVwdCgpID8gIklSUSIgOiAiVEFTSyIsIHNtcF9wcm9jZXNzb3JfaWQoKSk7CisJLyoKKwkgKiBCeSBhbHdheXMgY2xlYXJpbmcgU1RTIGJlZm9yZSBoYW5kbGluZyBhbGwgaW5kaWNhdGlvbnMsIHdlIGNhbgorCSAqIGVuc3VyZSBhIGhhcmR3YXJlIFNUUyAwLT4xIGNoYW5nZSBhZnRlciB0aGlzIGNsZWFyaW5nIGNhbiBhbHdheXMKKwkgKiB0cmlnZ2VyIGEgR1BFIGludGVycnVwdC4KKwkgKi8KKwlhY3BpX2VjX2NsZWFyX2dwZShlYyk7CiAJc3RhdHVzID0gYWNwaV9lY19yZWFkX3N0YXR1cyhlYyk7CiAJdCA9IGVjLT5jdXJyOwogCWlmICghdCkKQEAgLTIyMyw2ICs0NjgsNyBAQAogCQkJCXQtPnJkYXRhW3QtPnJpKytdID0gYWNwaV9lY19yZWFkX2RhdGEoZWMpOwogCQkJCWlmICh0LT5ybGVuID09IHQtPnJpKSB7CiAJCQkJCXQtPmZsYWdzIHw9IEFDUElfRUNfQ09NTUFORF9DT01QTEVURTsKKwkJCQkJYWNwaV9lY19jb21wbGV0ZV9ldmVudChlYyk7CiAJCQkJCWlmICh0LT5jb21tYW5kID09IEFDUElfRUNfQ09NTUFORF9RVUVSWSkKIAkJCQkJCXByX2RlYnVnKCIqKioqKiBDb21tYW5kKCVzKSBoYXJkd2FyZSBjb21wbGV0aW9uICoqKioqXG4iLAogCQkJCQkJCSBhY3BpX2VjX2NtZF9zdHJpbmcodC0+Y29tbWFuZCkpOwpAQCAtMjMzLDI1ICs0NzksMjkgQEAKIAkJfSBlbHNlIGlmICh0LT53bGVuID09IHQtPndpICYmCiAJCQkgICAoc3RhdHVzICYgQUNQSV9FQ19GTEFHX0lCRikgPT0gMCkgewogCQkJdC0+ZmxhZ3MgfD0gQUNQSV9FQ19DT01NQU5EX0NPTVBMRVRFOworCQkJYWNwaV9lY19jb21wbGV0ZV9ldmVudChlYyk7CiAJCQl3YWtldXAgPSB0cnVlOwogCQl9Ci0JCXJldHVybiB3YWtldXA7CisJCWdvdG8gb3V0OwogCX0gZWxzZSB7CiAJCWlmIChFQ19GTEFHU19RVUVSWV9IQU5EU0hBS0UgJiYKIAkJICAgICEoc3RhdHVzICYgQUNQSV9FQ19GTEFHX1NDSSkgJiYKIAkJICAgICh0LT5jb21tYW5kID09IEFDUElfRUNfQ09NTUFORF9RVUVSWSkpIHsKIAkJCXQtPmZsYWdzIHw9IEFDUElfRUNfQ09NTUFORF9QT0xMOworCQkJYWNwaV9lY19jb21wbGV0ZV9kZXRlY3Rpb24oZWMpOwogCQkJdC0+cmRhdGFbdC0+cmkrK10gPSAweDAwOwogCQkJdC0+ZmxhZ3MgfD0gQUNQSV9FQ19DT01NQU5EX0NPTVBMRVRFOworCQkJYWNwaV9lY19jb21wbGV0ZV9ldmVudChlYyk7CiAJCQlwcl9kZWJ1ZygiKioqKiogQ29tbWFuZCglcykgc29mdHdhcmUgY29tcGxldGlvbiAqKioqKlxuIiwKIAkJCQkgYWNwaV9lY19jbWRfc3RyaW5nKHQtPmNvbW1hbmQpKTsKIAkJCXdha2V1cCA9IHRydWU7CiAJCX0gZWxzZSBpZiAoKHN0YXR1cyAmIEFDUElfRUNfRkxBR19JQkYpID09IDApIHsKIAkJCWFjcGlfZWNfd3JpdGVfY21kKGVjLCB0LT5jb21tYW5kKTsKIAkJCXQtPmZsYWdzIHw9IEFDUElfRUNfQ09NTUFORF9QT0xMOworCQkJYWNwaV9lY19jb21wbGV0ZV9kZXRlY3Rpb24oZWMpOwogCQl9IGVsc2UKIAkJCWdvdG8gZXJyOwotCQlyZXR1cm4gd2FrZXVwOworCQlnb3RvIG91dDsKIAl9CiBlcnI6CiAJLyoKQEAgLTI1OSwyOCArNTA5LDI3IEBACiAJICogb3RoZXJ3aXNlIHdpbGwgdGFrZSBhIG5vdCBoYW5kbGVkIElSUSBhcyBhIGZhbHNlIG9uZS4KIAkgKi8KIAlpZiAoIShzdGF0dXMgJiBBQ1BJX0VDX0ZMQUdfU0NJKSkgewotCQlpZiAoaW5faW50ZXJydXB0KCkgJiYgdCkKLQkJCSsrdC0+aXJxX2NvdW50OworCQlpZiAoaW5faW50ZXJydXB0KCkgJiYgdCkgeworCQkJaWYgKHQtPmlycV9jb3VudCA8IGVjX3N0b3JtX3RocmVzaG9sZCkKKwkJCQkrK3QtPmlycV9jb3VudDsKKwkJCS8qIEFsbG93IHRyaWdnZXJpbmcgb24gMCB0aHJlc2hvbGQgKi8KKwkJCWlmICh0LT5pcnFfY291bnQgPT0gZWNfc3Rvcm1fdGhyZXNob2xkKQorCQkJCWFjcGlfZWNfc2V0X3N0b3JtKGVjLCBFQ19GTEFHU19DT01NQU5EX1NUT1JNKTsKKwkJfQogCX0KLQlyZXR1cm4gd2FrZXVwOworb3V0OgorCWlmIChzdGF0dXMgJiBBQ1BJX0VDX0ZMQUdfU0NJKQorCQlhY3BpX2VjX3N1Ym1pdF9kZXRlY3Rpb24oZWMpOworCWlmICh3YWtldXAgJiYgaW5faW50ZXJydXB0KCkpCisJCXdha2VfdXAoJmVjLT53YWl0KTsKIH0KIAogc3RhdGljIHZvaWQgc3RhcnRfdHJhbnNhY3Rpb24oc3RydWN0IGFjcGlfZWMgKmVjKQogewogCWVjLT5jdXJyLT5pcnFfY291bnQgPSBlYy0+Y3Vyci0+d2kgPSBlYy0+Y3Vyci0+cmkgPSAwOwogCWVjLT5jdXJyLT5mbGFncyA9IDA7Ci0JKHZvaWQpYWR2YW5jZV90cmFuc2FjdGlvbihlYyk7Ci19Ci0KLXN0YXRpYyBpbnQgYWNwaV9lY19zeW5jX3F1ZXJ5KHN0cnVjdCBhY3BpX2VjICplYywgdTggKmRhdGEpOwotCi1zdGF0aWMgaW50IGVjX2NoZWNrX3NjaV9zeW5jKHN0cnVjdCBhY3BpX2VjICplYywgdTggc3RhdGUpCi17Ci0JaWYgKHN0YXRlICYgQUNQSV9FQ19GTEFHX1NDSSkgewotCQlpZiAoIXRlc3RfYW5kX3NldF9iaXQoRUNfRkxBR1NfUVVFUllfUEVORElORywgJmVjLT5mbGFncykpCi0JCQlyZXR1cm4gYWNwaV9lY19zeW5jX3F1ZXJ5KGVjLCBOVUxMKTsKLQl9Ci0JcmV0dXJuIDA7CisJZWMtPmN1cnItPnRpbWVzdGFtcCA9IGppZmZpZXM7CisJYWR2YW5jZV90cmFuc2FjdGlvbihlYyk7CiB9CiAKIHN0YXRpYyBpbnQgZWNfcG9sbChzdHJ1Y3QgYWNwaV9lYyAqZWMpCkBAIC0yOTEsMjAgKzU0MCwyNSBAQAogCXdoaWxlIChyZXBlYXQtLSkgewogCQl1bnNpZ25lZCBsb25nIGRlbGF5ID0gamlmZmllcyArCiAJCQltc2Vjc190b19qaWZmaWVzKGVjX2RlbGF5KTsKKwkJdW5zaWduZWQgbG9uZyB1c2VjcyA9IEFDUElfRUNfVURFTEFZX1BPTEw7CiAJCWRvIHsKIAkJCS8qIGRvbid0IHNsZWVwIHdpdGggZGlzYWJsZWQgaW50ZXJydXB0cyAqLwogCQkJaWYgKEVDX0ZMQUdTX01TSSB8fCBpcnFzX2Rpc2FibGVkKCkpIHsKLQkJCQl1ZGVsYXkoQUNQSV9FQ19NU0lfVURFTEFZKTsKKwkJCQl1c2VjcyA9IEFDUElfRUNfTVNJX1VERUxBWTsKKwkJCQl1ZGVsYXkodXNlY3MpOwogCQkJCWlmIChlY190cmFuc2FjdGlvbl9jb21wbGV0ZWQoZWMpKQogCQkJCQlyZXR1cm4gMDsKIAkJCX0gZWxzZSB7CiAJCQkJaWYgKHdhaXRfZXZlbnRfdGltZW91dChlYy0+d2FpdCwKIAkJCQkJCWVjX3RyYW5zYWN0aW9uX2NvbXBsZXRlZChlYyksCi0JCQkJCQltc2Vjc190b19qaWZmaWVzKDEpKSkKKwkJCQkJCXVzZWNzX3RvX2ppZmZpZXModXNlY3MpKSkKIAkJCQkJcmV0dXJuIDA7CiAJCQl9CiAJCQlzcGluX2xvY2tfaXJxc2F2ZSgmZWMtPmxvY2ssIGZsYWdzKTsKLQkJCSh2b2lkKWFkdmFuY2VfdHJhbnNhY3Rpb24oZWMpOworCQkJaWYgKHRpbWVfYWZ0ZXIoamlmZmllcywKKwkJCQkJZWMtPmN1cnItPnRpbWVzdGFtcCArCisJCQkJCXVzZWNzX3RvX2ppZmZpZXModXNlY3MpKSkKKwkJCQlhZHZhbmNlX3RyYW5zYWN0aW9uKGVjKTsKIAkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmVjLT5sb2NrLCBmbGFncyk7CiAJCX0gd2hpbGUgKHRpbWVfYmVmb3JlKGppZmZpZXMsIGRlbGF5KSk7CiAJCXByX2RlYnVnKCJjb250cm9sbGVyIHJlc2V0LCByZXN0YXJ0IHRyYW5zYWN0aW9uXG4iKTsKQEAgLTMyNSwyMSArNTc5LDI5IEBACiAJCXVkZWxheShBQ1BJX0VDX01TSV9VREVMQVkpOwogCS8qIHN0YXJ0IHRyYW5zYWN0aW9uICovCiAJc3Bpbl9sb2NrX2lycXNhdmUoJmVjLT5sb2NrLCB0bXApOworCS8qIEVuYWJsZSBHUEUgZm9yIGNvbW1hbmQgcHJvY2Vzc2luZyAoSUJGPTAvT0JGPTEpICovCisJaWYgKCFhY3BpX2VjX3N1Ym1pdF9mbHVzaGFibGVfcmVxdWVzdChlYywgdHJ1ZSkpIHsKKwkJcmV0ID0gLUVJTlZBTDsKKwkJZ290byB1bmxvY2s7CisJfQorCWVjX2RlYnVnX3JlZihlYywgIkluY3JlYXNlIGNvbW1hbmRcbiIpOwogCS8qIGZvbGxvd2luZyB0d28gYWN0aW9ucyBzaG91bGQgYmUga2VwdCBhdG9taWMgKi8KIAllYy0+Y3VyciA9IHQ7CiAJcHJfZGVidWcoIioqKioqIENvbW1hbmQoJXMpIHN0YXJ0ZWQgKioqKipcbiIsCiAJCSBhY3BpX2VjX2NtZF9zdHJpbmcodC0+Y29tbWFuZCkpOwogCXN0YXJ0X3RyYW5zYWN0aW9uKGVjKTsKLQlpZiAoZWMtPmN1cnItPmNvbW1hbmQgPT0gQUNQSV9FQ19DT01NQU5EX1FVRVJZKSB7Ci0JCWNsZWFyX2JpdChFQ19GTEFHU19RVUVSWV9QRU5ESU5HLCAmZWMtPmZsYWdzKTsKLQkJcHJfZGVidWcoIioqKioqIEV2ZW50IHN0b3BwZWQgKioqKipcbiIpOwotCX0KIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZlYy0+bG9jaywgdG1wKTsKIAlyZXQgPSBlY19wb2xsKGVjKTsKIAlzcGluX2xvY2tfaXJxc2F2ZSgmZWMtPmxvY2ssIHRtcCk7CisJaWYgKHQtPmlycV9jb3VudCA9PSBlY19zdG9ybV90aHJlc2hvbGQpCisJCWFjcGlfZWNfY2xlYXJfc3Rvcm0oZWMsIEVDX0ZMQUdTX0NPTU1BTkRfU1RPUk0pOwogCXByX2RlYnVnKCIqKioqKiBDb21tYW5kKCVzKSBzdG9wcGVkICoqKioqXG4iLAogCQkgYWNwaV9lY19jbWRfc3RyaW5nKHQtPmNvbW1hbmQpKTsKIAllYy0+Y3VyciA9IE5VTEw7CisJLyogRGlzYWJsZSBHUEUgZm9yIGNvbW1hbmQgcHJvY2Vzc2luZyAoSUJGPTAvT0JGPTEpICovCisJYWNwaV9lY19jb21wbGV0ZV9yZXF1ZXN0KGVjKTsKKwllY19kZWJ1Z19yZWYoZWMsICJEZWNyZWFzZSBjb21tYW5kXG4iKTsKK3VubG9jazoKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZlYy0+bG9jaywgdG1wKTsKIAlyZXR1cm4gcmV0OwogfQpAQCAtMzU0LDEwICs2MTYsNiBAQAogCWlmICh0LT5yZGF0YSkKIAkJbWVtc2V0KHQtPnJkYXRhLCAwLCB0LT5ybGVuKTsKIAltdXRleF9sb2NrKCZlYy0+bXV0ZXgpOwotCWlmICh0ZXN0X2JpdChFQ19GTEFHU19CTE9DS0VELCAmZWMtPmZsYWdzKSkgewotCQlzdGF0dXMgPSAtRUlOVkFMOwotCQlnb3RvIHVubG9jazsKLQl9CiAJaWYgKGVjLT5nbG9iYWxfbG9jaykgewogCQlzdGF0dXMgPSBhY3BpX2FjcXVpcmVfZ2xvYmFsX2xvY2soQUNQSV9FQ19VREVMQVlfR0xLLCAmZ2xrKTsKIAkJaWYgKEFDUElfRkFJTFVSRShzdGF0dXMpKSB7CkBAIC0zNjUsMjYgKzYyMywxMSBAQAogCQkJZ290byB1bmxvY2s7CiAJCX0KIAl9Ci0JLyogZGlzYWJsZSBHUEUgZHVyaW5nIHRyYW5zYWN0aW9uIGlmIHN0b3JtIGlzIGRldGVjdGVkICovCi0JaWYgKHRlc3RfYml0KEVDX0ZMQUdTX0dQRV9TVE9STSwgJmVjLT5mbGFncykpIHsKLQkJLyogSXQgaGFzIHRvIGJlIGRpc2FibGVkLCBzbyB0aGF0IGl0IGRvZXNuJ3QgdHJpZ2dlci4gKi8KLQkJYWNwaV9kaXNhYmxlX2dwZShOVUxMLCBlYy0+Z3BlKTsKLQl9CiAKIAlzdGF0dXMgPSBhY3BpX2VjX3RyYW5zYWN0aW9uX3VubG9ja2VkKGVjLCB0KTsKIAotCS8qIGNoZWNrIGlmIHdlIHJlY2VpdmVkIFNDSSBkdXJpbmcgdHJhbnNhY3Rpb24gKi8KLQllY19jaGVja19zY2lfc3luYyhlYywgYWNwaV9lY19yZWFkX3N0YXR1cyhlYykpOwotCWlmICh0ZXN0X2JpdChFQ19GTEFHU19HUEVfU1RPUk0sICZlYy0+ZmxhZ3MpKSB7CisJaWYgKHRlc3RfYml0KEVDX0ZMQUdTX0NPTU1BTkRfU1RPUk0sICZlYy0+ZmxhZ3MpKQogCQltc2xlZXAoMSk7Ci0JCS8qIEl0IGlzIHNhZmUgdG8gZW5hYmxlIHRoZSBHUEUgb3V0c2lkZSBvZiB0aGUgdHJhbnNhY3Rpb24uICovCi0JCWFjcGlfZW5hYmxlX2dwZShOVUxMLCBlYy0+Z3BlKTsKLQl9IGVsc2UgaWYgKHQtPmlycV9jb3VudCA+IGVjX3N0b3JtX3RocmVzaG9sZCkgewotCQlwcl9pbmZvKCJHUEUgc3Rvcm0gZGV0ZWN0ZWQoJWQgR1BFcyksICIKLQkJCSJ0cmFuc2FjdGlvbnMgd2lsbCB1c2UgcG9sbGluZyBtb2RlXG4iLAotCQkJdC0+aXJxX2NvdW50KTsKLQkJc2V0X2JpdChFQ19GTEFHU19HUEVfU1RPUk0sICZlYy0+ZmxhZ3MpOwotCX0KIAlpZiAoZWMtPmdsb2JhbF9sb2NrKQogCQlhY3BpX3JlbGVhc2VfZ2xvYmFsX2xvY2soZ2xrKTsKIHVubG9jazoKQEAgLTUwMCw3ICs3NDMsNyBAQAogCXU4IHZhbHVlID0gMDsKIAogCWZvciAoaSA9IDA7IGkgPCBBQ1BJX0VDX0NMRUFSX01BWDsgaSsrKSB7Ci0JCXN0YXR1cyA9IGFjcGlfZWNfc3luY19xdWVyeShlYywgJnZhbHVlKTsKKwkJc3RhdHVzID0gYWNwaV9lY19xdWVyeShlYywgJnZhbHVlKTsKIAkJaWYgKHN0YXR1cyB8fCAhdmFsdWUpCiAJCQlicmVhazsKIAl9CkBAIC01MTEsNiArNzU0LDU3IEBACiAJCXByX2luZm8oIiVkIHN0YWxlIEVDIGV2ZW50cyBjbGVhcmVkXG4iLCBpKTsKIH0KIAorc3RhdGljIHZvaWQgYWNwaV9lY19zdGFydChzdHJ1Y3QgYWNwaV9lYyAqZWMsIGJvb2wgcmVzdW1pbmcpCit7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZlYy0+bG9jaywgZmxhZ3MpOworCWlmICghdGVzdF9hbmRfc2V0X2JpdChFQ19GTEFHU19TVEFSVEVELCAmZWMtPmZsYWdzKSkgeworCQlwcl9kZWJ1ZygiKysrKysgU3RhcnRpbmcgRUMgKysrKytcbiIpOworCQkvKiBFbmFibGUgR1BFIGZvciBldmVudCBwcm9jZXNzaW5nIChTQ0lfRVZUPTEpICovCisJCWlmICghcmVzdW1pbmcpIHsKKwkJCWFjcGlfZWNfc3VibWl0X3JlcXVlc3QoZWMpOworCQkJZWNfZGVidWdfcmVmKGVjLCAiSW5jcmVhc2UgZHJpdmVyXG4iKTsKKwkJfQorCQlwcl9pbmZvKCIrKysrKyBFQyBzdGFydGVkICsrKysrXG4iKTsKKwl9CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZWMtPmxvY2ssIGZsYWdzKTsKK30KKworc3RhdGljIGJvb2wgYWNwaV9lY19zdG9wcGVkKHN0cnVjdCBhY3BpX2VjICplYykKK3sKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCWJvb2wgZmx1c2hlZDsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZlYy0+bG9jaywgZmxhZ3MpOworCWZsdXNoZWQgPSBhY3BpX2VjX2ZsdXNoZWQoZWMpOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmVjLT5sb2NrLCBmbGFncyk7CisJcmV0dXJuIGZsdXNoZWQ7Cit9CisKK3N0YXRpYyB2b2lkIGFjcGlfZWNfc3RvcChzdHJ1Y3QgYWNwaV9lYyAqZWMsIGJvb2wgc3VzcGVuZGluZykKK3sKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJmVjLT5sb2NrLCBmbGFncyk7CisJaWYgKGFjcGlfZWNfc3RhcnRlZChlYykpIHsKKwkJcHJfZGVidWcoIisrKysrIFN0b3BwaW5nIEVDICsrKysrXG4iKTsKKwkJc2V0X2JpdChFQ19GTEFHU19TVE9QUEVELCAmZWMtPmZsYWdzKTsKKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZWMtPmxvY2ssIGZsYWdzKTsKKwkJd2FpdF9ldmVudChlYy0+d2FpdCwgYWNwaV9lY19zdG9wcGVkKGVjKSk7CisJCXNwaW5fbG9ja19pcnFzYXZlKCZlYy0+bG9jaywgZmxhZ3MpOworCQkvKiBEaXNhYmxlIEdQRSBmb3IgZXZlbnQgcHJvY2Vzc2luZyAoU0NJX0VWVD0xKSAqLworCQlpZiAoIXN1c3BlbmRpbmcpIHsKKwkJCWFjcGlfZWNfY29tcGxldGVfcmVxdWVzdChlYyk7CisJCQllY19kZWJ1Z19yZWYoZWMsICJEZWNyZWFzZSBkcml2ZXJcbiIpOworCQl9CisJCWNsZWFyX2JpdChFQ19GTEFHU19TVEFSVEVELCAmZWMtPmZsYWdzKTsKKwkJY2xlYXJfYml0KEVDX0ZMQUdTX1NUT1BQRUQsICZlYy0+ZmxhZ3MpOworCQlwcl9pbmZvKCIrKysrKyBFQyBzdG9wcGVkICsrKysrXG4iKTsKKwl9CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZWMtPmxvY2ssIGZsYWdzKTsKK30KKwogdm9pZCBhY3BpX2VjX2Jsb2NrX3RyYW5zYWN0aW9ucyh2b2lkKQogewogCXN0cnVjdCBhY3BpX2VjICplYyA9IGZpcnN0X2VjOwpAQCAtNTIwLDcgKzgxNCw3IEBACiAKIAltdXRleF9sb2NrKCZlYy0+bXV0ZXgpOwogCS8qIFByZXZlbnQgdHJhbnNhY3Rpb25zIGZyb20gYmVpbmcgY2FycmllZCBvdXQgKi8KLQlzZXRfYml0KEVDX0ZMQUdTX0JMT0NLRUQsICZlYy0+ZmxhZ3MpOworCWFjcGlfZWNfc3RvcChlYywgdHJ1ZSk7CiAJbXV0ZXhfdW5sb2NrKCZlYy0+bXV0ZXgpOwogfQogCkBAIC01MzEsMTQgKzgyNSwxMSBAQAogCWlmICghZWMpCiAJCXJldHVybjsKIAotCW11dGV4X2xvY2soJmVjLT5tdXRleCk7CiAJLyogQWxsb3cgdHJhbnNhY3Rpb25zIHRvIGJlIGNhcnJpZWQgb3V0IGFnYWluICovCi0JY2xlYXJfYml0KEVDX0ZMQUdTX0JMT0NLRUQsICZlYy0+ZmxhZ3MpOworCWFjcGlfZWNfc3RhcnQoZWMsIHRydWUpOwogCiAJaWYgKEVDX0ZMQUdTX0NMRUFSX09OX1JFU1VNRSkKIAkJYWNwaV9lY19jbGVhcihlYyk7Ci0KLQltdXRleF91bmxvY2soJmVjLT5tdXRleCk7CiB9CiAKIHZvaWQgYWNwaV9lY191bmJsb2NrX3RyYW5zYWN0aW9uc19lYXJseSh2b2lkKQpAQCAtNTQ4LDM2ICs4MzksMzMgQEAKIAkgKiBhdG9taWMgY29udGV4dCBkdXJpbmcgd2FrZXVwLCBzbyB3ZSBkb24ndCBuZWVkIHRvIGFjcXVpcmUgdGhlIG11dGV4KS4KIAkgKi8KIAlpZiAoZmlyc3RfZWMpCi0JCWNsZWFyX2JpdChFQ19GTEFHU19CTE9DS0VELCAmZmlyc3RfZWMtPmZsYWdzKTsKLX0KLQotc3RhdGljIGludCBhY3BpX2VjX3F1ZXJ5X3VubG9ja2VkKHN0cnVjdCBhY3BpX2VjICplYywgdTggKmRhdGEpCi17Ci0JaW50IHJlc3VsdDsKLQl1OCBkOwotCXN0cnVjdCB0cmFuc2FjdGlvbiB0ID0gey5jb21tYW5kID0gQUNQSV9FQ19DT01NQU5EX1FVRVJZLAotCQkJCS53ZGF0YSA9IE5VTEwsIC5yZGF0YSA9ICZkLAotCQkJCS53bGVuID0gMCwgLnJsZW4gPSAxfTsKLQotCWlmICghZWMgfHwgIWRhdGEpCi0JCXJldHVybiAtRUlOVkFMOwotCS8qCi0JICogUXVlcnkgdGhlIEVDIHRvIGZpbmQgb3V0IHdoaWNoIF9ReHggbWV0aG9kIHdlIG5lZWQgdG8gZXZhbHVhdGUuCi0JICogTm90ZSB0aGF0IHN1Y2Nlc3NmdWwgY29tcGxldGlvbiBvZiB0aGUgcXVlcnkgY2F1c2VzIHRoZSBBQ1BJX0VDX1NDSQotCSAqIGJpdCB0byBiZSBjbGVhcmVkIChhbmQgdGh1cyBjbGVhcmluZyB0aGUgaW50ZXJydXB0IHNvdXJjZSkuCi0JICovCi0JcmVzdWx0ID0gYWNwaV9lY190cmFuc2FjdGlvbl91bmxvY2tlZChlYywgJnQpOwotCWlmIChyZXN1bHQpCi0JCXJldHVybiByZXN1bHQ7Ci0JaWYgKCFkKQotCQlyZXR1cm4gLUVOT0RBVEE7Ci0JKmRhdGEgPSBkOwotCXJldHVybiAwOworCQlhY3BpX2VjX3N0YXJ0KGZpcnN0X2VjLCB0cnVlKTsKIH0KIAogLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgRXZlbnQgTWFuYWdlbWVudAogICAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KK3N0YXRpYyBzdHJ1Y3QgYWNwaV9lY19xdWVyeV9oYW5kbGVyICoKK2FjcGlfZWNfZ2V0X3F1ZXJ5X2hhbmRsZXIoc3RydWN0IGFjcGlfZWNfcXVlcnlfaGFuZGxlciAqaGFuZGxlcikKK3sKKwlpZiAoaGFuZGxlcikKKwkJa3JlZl9nZXQoJmhhbmRsZXItPmtyZWYpOworCXJldHVybiBoYW5kbGVyOworfQorCitzdGF0aWMgdm9pZCBhY3BpX2VjX3F1ZXJ5X2hhbmRsZXJfcmVsZWFzZShzdHJ1Y3Qga3JlZiAqa3JlZikKK3sKKwlzdHJ1Y3QgYWNwaV9lY19xdWVyeV9oYW5kbGVyICpoYW5kbGVyID0KKwkJY29udGFpbmVyX29mKGtyZWYsIHN0cnVjdCBhY3BpX2VjX3F1ZXJ5X2hhbmRsZXIsIGtyZWYpOworCisJa2ZyZWUoaGFuZGxlcik7Cit9CisKK3N0YXRpYyB2b2lkIGFjcGlfZWNfcHV0X3F1ZXJ5X2hhbmRsZXIoc3RydWN0IGFjcGlfZWNfcXVlcnlfaGFuZGxlciAqaGFuZGxlcikKK3sKKwlrcmVmX3B1dCgmaGFuZGxlci0+a3JlZiwgYWNwaV9lY19xdWVyeV9oYW5kbGVyX3JlbGVhc2UpOworfQorCiBpbnQgYWNwaV9lY19hZGRfcXVlcnlfaGFuZGxlcihzdHJ1Y3QgYWNwaV9lYyAqZWMsIHU4IHF1ZXJ5X2JpdCwKIAkJCSAgICAgIGFjcGlfaGFuZGxlIGhhbmRsZSwgYWNwaV9lY19xdWVyeV9mdW5jIGZ1bmMsCiAJCQkgICAgICB2b2lkICpkYXRhKQpAQCAtNTkzLDYgKzg4MSw3IEBACiAJaGFuZGxlci0+ZnVuYyA9IGZ1bmM7CiAJaGFuZGxlci0+ZGF0YSA9IGRhdGE7CiAJbXV0ZXhfbG9jaygmZWMtPm11dGV4KTsKKwlrcmVmX2luaXQoJmhhbmRsZXItPmtyZWYpOwogCWxpc3RfYWRkKCZoYW5kbGVyLT5ub2RlLCAmZWMtPmxpc3QpOwogCW11dGV4X3VubG9jaygmZWMtPm11dGV4KTsKIAlyZXR1cm4gMDsKQEAgLTYwMiwxNSArODkxLDE4IEBACiB2b2lkIGFjcGlfZWNfcmVtb3ZlX3F1ZXJ5X2hhbmRsZXIoc3RydWN0IGFjcGlfZWMgKmVjLCB1OCBxdWVyeV9iaXQpCiB7CiAJc3RydWN0IGFjcGlfZWNfcXVlcnlfaGFuZGxlciAqaGFuZGxlciwgKnRtcDsKKwlMSVNUX0hFQUQoZnJlZV9saXN0KTsKIAogCW11dGV4X2xvY2soJmVjLT5tdXRleCk7CiAJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKGhhbmRsZXIsIHRtcCwgJmVjLT5saXN0LCBub2RlKSB7CiAJCWlmIChxdWVyeV9iaXQgPT0gaGFuZGxlci0+cXVlcnlfYml0KSB7Ci0JCQlsaXN0X2RlbCgmaGFuZGxlci0+bm9kZSk7Ci0JCQlrZnJlZShoYW5kbGVyKTsKKwkJCWxpc3RfZGVsX2luaXQoJmhhbmRsZXItPm5vZGUpOworCQkJbGlzdF9hZGQoJmhhbmRsZXItPm5vZGUsICZmcmVlX2xpc3QpOwogCQl9CiAJfQogCW11dGV4X3VubG9jaygmZWMtPm11dGV4KTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KGhhbmRsZXIsICZmcmVlX2xpc3QsIG5vZGUpCisJCWFjcGlfZWNfcHV0X3F1ZXJ5X2hhbmRsZXIoaGFuZGxlcik7CiB9CiBFWFBPUlRfU1lNQk9MX0dQTChhY3BpX2VjX3JlbW92ZV9xdWVyeV9oYW5kbGVyKTsKIApAQCAtNjI2LDU5ICs5MTgsNTggQEAKIAllbHNlIGlmIChoYW5kbGVyLT5oYW5kbGUpCiAJCWFjcGlfZXZhbHVhdGVfb2JqZWN0KGhhbmRsZXItPmhhbmRsZSwgTlVMTCwgTlVMTCwgTlVMTCk7CiAJcHJfZGVidWcoIiMjIyMjIFF1ZXJ5KDB4JTAyeCkgc3RvcHBlZCAjIyMjI1xuIiwgaGFuZGxlci0+cXVlcnlfYml0KTsKLQlrZnJlZShoYW5kbGVyKTsKKwlhY3BpX2VjX3B1dF9xdWVyeV9oYW5kbGVyKGhhbmRsZXIpOwogfQogCi1zdGF0aWMgaW50IGFjcGlfZWNfc3luY19xdWVyeShzdHJ1Y3QgYWNwaV9lYyAqZWMsIHU4ICpkYXRhKQorc3RhdGljIGludCBhY3BpX2VjX3F1ZXJ5KHN0cnVjdCBhY3BpX2VjICplYywgdTggKmRhdGEpCiB7CiAJdTggdmFsdWUgPSAwOwotCWludCBzdGF0dXM7Ci0Jc3RydWN0IGFjcGlfZWNfcXVlcnlfaGFuZGxlciAqaGFuZGxlciwgKmNvcHk7CisJaW50IHJlc3VsdDsKKwlhY3BpX3N0YXR1cyBzdGF0dXM7CisJc3RydWN0IGFjcGlfZWNfcXVlcnlfaGFuZGxlciAqaGFuZGxlcjsKKwlzdHJ1Y3QgdHJhbnNhY3Rpb24gdCA9IHsuY29tbWFuZCA9IEFDUElfRUNfQ09NTUFORF9RVUVSWSwKKwkJCQkud2RhdGEgPSBOVUxMLCAucmRhdGEgPSAmdmFsdWUsCisJCQkJLndsZW4gPSAwLCAucmxlbiA9IDF9OwogCi0Jc3RhdHVzID0gYWNwaV9lY19xdWVyeV91bmxvY2tlZChlYywgJnZhbHVlKTsKKwkvKgorCSAqIFF1ZXJ5IHRoZSBFQyB0byBmaW5kIG91dCB3aGljaCBfUXh4IG1ldGhvZCB3ZSBuZWVkIHRvIGV2YWx1YXRlLgorCSAqIE5vdGUgdGhhdCBzdWNjZXNzZnVsIGNvbXBsZXRpb24gb2YgdGhlIHF1ZXJ5IGNhdXNlcyB0aGUgQUNQSV9FQ19TQ0kKKwkgKiBiaXQgdG8gYmUgY2xlYXJlZCAoYW5kIHRodXMgY2xlYXJpbmcgdGhlIGludGVycnVwdCBzb3VyY2UpLgorCSAqLworCXJlc3VsdCA9IGFjcGlfZWNfdHJhbnNhY3Rpb24oZWMsICZ0KTsKKwlpZiAocmVzdWx0KQorCQlyZXR1cm4gcmVzdWx0OwogCWlmIChkYXRhKQogCQkqZGF0YSA9IHZhbHVlOwotCWlmIChzdGF0dXMpCi0JCXJldHVybiBzdGF0dXM7CisJaWYgKCF2YWx1ZSkKKwkJcmV0dXJuIC1FTk9EQVRBOwogCisJbXV0ZXhfbG9jaygmZWMtPm11dGV4KTsKIAlsaXN0X2Zvcl9lYWNoX2VudHJ5KGhhbmRsZXIsICZlYy0+bGlzdCwgbm9kZSkgewogCQlpZiAodmFsdWUgPT0gaGFuZGxlci0+cXVlcnlfYml0KSB7CiAJCQkvKiBoYXZlIGN1c3RvbSBoYW5kbGVyIGZvciB0aGlzIGJpdCAqLwotCQkJY29weSA9IGttYWxsb2Moc2l6ZW9mKCpoYW5kbGVyKSwgR0ZQX0tFUk5FTCk7Ci0JCQlpZiAoIWNvcHkpCi0JCQkJcmV0dXJuIC1FTk9NRU07Ci0JCQltZW1jcHkoY29weSwgaGFuZGxlciwgc2l6ZW9mKCpjb3B5KSk7CisJCQloYW5kbGVyID0gYWNwaV9lY19nZXRfcXVlcnlfaGFuZGxlcihoYW5kbGVyKTsKIAkJCXByX2RlYnVnKCIjIyMjIyBRdWVyeSgweCUwMngpIHNjaGVkdWxlZCAjIyMjI1xuIiwKIAkJCQkgaGFuZGxlci0+cXVlcnlfYml0KTsKLQkJCXJldHVybiBhY3BpX29zX2V4ZWN1dGUoKGNvcHktPmZ1bmMpID8KKwkJCXN0YXR1cyA9IGFjcGlfb3NfZXhlY3V0ZSgoaGFuZGxlci0+ZnVuYykgPwogCQkJCU9TTF9OT1RJRllfSEFORExFUiA6IE9TTF9HUEVfSEFORExFUiwKLQkJCQlhY3BpX2VjX3J1biwgY29weSk7CisJCQkJYWNwaV9lY19ydW4sIGhhbmRsZXIpOworCQkJaWYgKEFDUElfRkFJTFVSRShzdGF0dXMpKQorCQkJCXJlc3VsdCA9IC1FQlVTWTsKKwkJCWJyZWFrOwogCQl9CiAJfQotCXJldHVybiAwOwotfQotCi1zdGF0aWMgdm9pZCBhY3BpX2VjX2dwZV9xdWVyeSh2b2lkICplY19jeHQpCi17Ci0Jc3RydWN0IGFjcGlfZWMgKmVjID0gZWNfY3h0OwotCi0JaWYgKCFlYykKLQkJcmV0dXJuOwotCW11dGV4X2xvY2soJmVjLT5tdXRleCk7Ci0JYWNwaV9lY19zeW5jX3F1ZXJ5KGVjLCBOVUxMKTsKIAltdXRleF91bmxvY2soJmVjLT5tdXRleCk7CisJcmV0dXJuIHJlc3VsdDsKIH0KIAotc3RhdGljIGludCBlY19jaGVja19zY2koc3RydWN0IGFjcGlfZWMgKmVjLCB1OCBzdGF0ZSkKK3N0YXRpYyB2b2lkIGFjcGlfZWNfZ3BlX3BvbGxlcihzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCiB7Ci0JaWYgKHN0YXRlICYgQUNQSV9FQ19GTEFHX1NDSSkgewotCQlpZiAoIXRlc3RfYW5kX3NldF9iaXQoRUNfRkxBR1NfUVVFUllfUEVORElORywgJmVjLT5mbGFncykpIHsKLQkJCXByX2RlYnVnKCIqKioqKiBFdmVudCBzdGFydGVkICoqKioqXG4iKTsKLQkJCXJldHVybiBhY3BpX29zX2V4ZWN1dGUoT1NMX05PVElGWV9IQU5ETEVSLAotCQkJCWFjcGlfZWNfZ3BlX3F1ZXJ5LCBlYyk7Ci0JCX0KLQl9Ci0JcmV0dXJuIDA7CisJc3RydWN0IGFjcGlfZWMgKmVjID0gY29udGFpbmVyX29mKHdvcmssIHN0cnVjdCBhY3BpX2VjLCB3b3JrKTsKKworCXByX2RlYnVnKCIqKioqKiBFdmVudCBwb2xsZXIgc3RhcnRlZCAqKioqKlxuIik7CisJYWNwaV9lY19xdWVyeShlYywgTlVMTCk7CisJcHJfZGVidWcoIioqKioqIEV2ZW50IHBvbGxlciBzdG9wcGVkICoqKioqXG4iKTsKIH0KIAogc3RhdGljIHUzMiBhY3BpX2VjX2dwZV9oYW5kbGVyKGFjcGlfaGFuZGxlIGdwZV9kZXZpY2UsCkBAIC02ODgsMTEgKzk3OSw5IEBACiAJc3RydWN0IGFjcGlfZWMgKmVjID0gZGF0YTsKIAogCXNwaW5fbG9ja19pcnFzYXZlKCZlYy0+bG9jaywgZmxhZ3MpOwotCWlmIChhZHZhbmNlX3RyYW5zYWN0aW9uKGVjKSkKLQkJd2FrZV91cCgmZWMtPndhaXQpOworCWFkdmFuY2VfdHJhbnNhY3Rpb24oZWMpOwogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmVjLT5sb2NrLCBmbGFncyk7Ci0JZWNfY2hlY2tfc2NpKGVjLCBhY3BpX2VjX3JlYWRfc3RhdHVzKGVjKSk7Ci0JcmV0dXJuIEFDUElfSU5URVJSVVBUX0hBTkRMRUQgfCBBQ1BJX1JFRU5BQkxFX0dQRTsKKwlyZXR1cm4gQUNQSV9JTlRFUlJVUFRfSEFORExFRDsKIH0KIAogLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KQEAgLTc1MCwxMSArMTAzOSwxMSBAQAogCiAJaWYgKCFlYykKIAkJcmV0dXJuIE5VTEw7Ci0JZWMtPmZsYWdzID0gMSA8PCBFQ19GTEFHU19RVUVSWV9QRU5ESU5HOwogCW11dGV4X2luaXQoJmVjLT5tdXRleCk7CiAJaW5pdF93YWl0cXVldWVfaGVhZCgmZWMtPndhaXQpOwogCUlOSVRfTElTVF9IRUFEKCZlYy0+bGlzdCk7CiAJc3Bpbl9sb2NrX2luaXQoJmVjLT5sb2NrKTsKKwlJTklUX1dPUksoJmVjLT53b3JrLCBhY3BpX2VjX2dwZV9wb2xsZXIpOwogCXJldHVybiBlYzsKIH0KIApAQCAtODEwLDEzICsxMDk5LDEzIEBACiAKIAlpZiAodGVzdF9iaXQoRUNfRkxBR1NfSEFORExFUlNfSU5TVEFMTEVELCAmZWMtPmZsYWdzKSkKIAkJcmV0dXJuIDA7Ci0Jc3RhdHVzID0gYWNwaV9pbnN0YWxsX2dwZV9oYW5kbGVyKE5VTEwsIGVjLT5ncGUsCisJc3RhdHVzID0gYWNwaV9pbnN0YWxsX2dwZV9yYXdfaGFuZGxlcihOVUxMLCBlYy0+Z3BlLAogCQkJCSAgQUNQSV9HUEVfRURHRV9UUklHR0VSRUQsCiAJCQkJICAmYWNwaV9lY19ncGVfaGFuZGxlciwgZWMpOwogCWlmIChBQ1BJX0ZBSUxVUkUoc3RhdHVzKSkKIAkJcmV0dXJuIC1FTk9ERVY7CiAKLQlhY3BpX2VuYWJsZV9ncGUoTlVMTCwgZWMtPmdwZSk7CisJYWNwaV9lY19zdGFydChlYywgZmFsc2UpOwogCXN0YXR1cyA9IGFjcGlfaW5zdGFsbF9hZGRyZXNzX3NwYWNlX2hhbmRsZXIoZWMtPmhhbmRsZSwKIAkJCQkJCSAgICBBQ1BJX0FEUl9TUEFDRV9FQywKIAkJCQkJCSAgICAmYWNwaV9lY19zcGFjZV9oYW5kbGVyLApAQCAtODMxLDcgKzExMjAsNyBAQAogCQkJcHJfZXJyKCJGYWlsIGluIGV2YWx1YXRpbmcgdGhlIF9SRUcgb2JqZWN0IgogCQkJCSIgb2YgRUMgZGV2aWNlLiBCcm9rZW4gYmlvcyBpcyBzdXNwZWN0ZWQuXG4iKTsKIAkJfSBlbHNlIHsKLQkJCWFjcGlfZGlzYWJsZV9ncGUoTlVMTCwgZWMtPmdwZSk7CisJCQlhY3BpX2VjX3N0b3AoZWMsIGZhbHNlKTsKIAkJCWFjcGlfcmVtb3ZlX2dwZV9oYW5kbGVyKE5VTEwsIGVjLT5ncGUsCiAJCQkJJmFjcGlfZWNfZ3BlX2hhbmRsZXIpOwogCQkJcmV0dXJuIC1FTk9ERVY7CkBAIC04NDYsNyArMTEzNSw3IEBACiB7CiAJaWYgKCF0ZXN0X2JpdChFQ19GTEFHU19IQU5ETEVSU19JTlNUQUxMRUQsICZlYy0+ZmxhZ3MpKQogCQlyZXR1cm47Ci0JYWNwaV9kaXNhYmxlX2dwZShOVUxMLCBlYy0+Z3BlKTsKKwlhY3BpX2VjX3N0b3AoZWMsIGZhbHNlKTsKIAlpZiAoQUNQSV9GQUlMVVJFKGFjcGlfcmVtb3ZlX2FkZHJlc3Nfc3BhY2VfaGFuZGxlcihlYy0+aGFuZGxlLAogCQkJCUFDUElfQURSX1NQQUNFX0VDLCAmYWNwaV9lY19zcGFjZV9oYW5kbGVyKSkpCiAJCXByX2VycigiZmFpbGVkIHRvIHJlbW92ZSBzcGFjZSBoYW5kbGVyXG4iKTsKQEAgLTkwMCwxNCArMTE4OSwxMSBAQAogCXJldCA9IGVjX2luc3RhbGxfaGFuZGxlcnMoZWMpOwogCiAJLyogRUMgaXMgZnVsbHkgb3BlcmF0aW9uYWwsIGFsbG93IHF1ZXJpZXMgKi8KLQljbGVhcl9iaXQoRUNfRkxBR1NfUVVFUllfUEVORElORywgJmVjLT5mbGFncyk7CisJYWNwaV9lY19lbmFibGVfZXZlbnQoZWMpOwogCiAJLyogQ2xlYXIgc3RhbGUgX1EgZXZlbnRzIGlmIGhhcmR3YXJlIG1pZ2h0IHJlcXVpcmUgdGhhdCAqLwotCWlmIChFQ19GTEFHU19DTEVBUl9PTl9SRVNVTUUpIHsKLQkJbXV0ZXhfbG9jaygmZWMtPm11dGV4KTsKKwlpZiAoRUNfRkxBR1NfQ0xFQVJfT05fUkVTVU1FKQogCQlhY3BpX2VjX2NsZWFyKGVjKTsKLQkJbXV0ZXhfdW5sb2NrKCZlYy0+bXV0ZXgpOwotCX0KIAlyZXR1cm4gcmV0OwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvaW50ZXJuYWwuaCBiL2RyaXZlcnMvYWNwaS9pbnRlcm5hbC5oCmluZGV4IDE2M2U4MmYuLjU2YjMyMWEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9pbnRlcm5hbC5oCisrKyBiL2RyaXZlcnMvYWNwaS9pbnRlcm5hbC5oCkBAIC0zNSw2ICszNSwxMyBAQAogaW50IGFjcGlfc3lzZnNfaW5pdCh2b2lkKTsKIHZvaWQgYWNwaV9jb250YWluZXJfaW5pdCh2b2lkKTsKIHZvaWQgYWNwaV9tZW1vcnlfaG90cGx1Z19pbml0KHZvaWQpOworI2lmZGVmCUNPTkZJR19BQ1BJX0hPVFBMVUdfSU9BUElDCitpbnQgYWNwaV9pb2FwaWNfYWRkKHN0cnVjdCBhY3BpX3BjaV9yb290ICpyb290KTsKK2ludCBhY3BpX2lvYXBpY19yZW1vdmUoc3RydWN0IGFjcGlfcGNpX3Jvb3QgKnJvb3QpOworI2Vsc2UKK3N0YXRpYyBpbmxpbmUgaW50IGFjcGlfaW9hcGljX2FkZChzdHJ1Y3QgYWNwaV9wY2lfcm9vdCAqcm9vdCkgeyByZXR1cm4gMDsgfQorc3RhdGljIGlubGluZSBpbnQgYWNwaV9pb2FwaWNfcmVtb3ZlKHN0cnVjdCBhY3BpX3BjaV9yb290ICpyb290KSB7IHJldHVybiAwOyB9CisjZW5kaWYKICNpZmRlZiBDT05GSUdfQUNQSV9ET0NLCiB2b2lkIHJlZ2lzdGVyX2RvY2tfZGVwZW5kZW50X2RldmljZShzdHJ1Y3QgYWNwaV9kZXZpY2UgKmFkZXYsCiAJCQkJICAgIGFjcGlfaGFuZGxlIGRzaGFuZGxlKTsKQEAgLTY4LDYgKzc1LDggQEAKICNlbmRpZgogdm9pZCBhY3BpX2xwc3NfaW5pdCh2b2lkKTsKIAordm9pZCBhY3BpX2FwZF9pbml0KHZvaWQpOworCiBhY3BpX3N0YXR1cyBhY3BpX2hvdHBsdWdfc2NoZWR1bGUoc3RydWN0IGFjcGlfZGV2aWNlICphZGV2LCB1MzIgc3JjKTsKIGJvb2wgYWNwaV9xdWV1ZV9ob3RwbHVnX3dvcmsoc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKTsKIHZvaWQgYWNwaV9kZXZpY2VfaG90cGx1ZyhzdHJ1Y3QgYWNwaV9kZXZpY2UgKmFkZXYsIHUzMiBzcmMpOwpAQCAtMTIyLDExICsxMzEsMTMgQEAKIAl1bnNpZ25lZCBsb25nIGRhdGFfYWRkcjsKIAl1bnNpZ25lZCBsb25nIGdsb2JhbF9sb2NrOwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJdW5zaWduZWQgbG9uZyByZWZlcmVuY2VfY291bnQ7CiAJc3RydWN0IG11dGV4IG11dGV4OwogCXdhaXRfcXVldWVfaGVhZF90IHdhaXQ7CiAJc3RydWN0IGxpc3RfaGVhZCBsaXN0OwogCXN0cnVjdCB0cmFuc2FjdGlvbiAqY3VycjsKIAlzcGlubG9ja190IGxvY2s7CisJc3RydWN0IHdvcmtfc3RydWN0IHdvcms7CiB9OwogCiBleHRlcm4gc3RydWN0IGFjcGlfZWMgKmZpcnN0X2VjOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2lvYXBpYy5jIGIvZHJpdmVycy9hY3BpL2lvYXBpYy5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmNjZGM4ZGIKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2FjcGkvaW9hcGljLmMKQEAgLTAsMCArMSwyMjkgQEAKKy8qCisgKiBJT0FQSUMvSU94QVBJQy9JT1NBUElDIGRyaXZlcgorICoKKyAqIENvcHlyaWdodCAoQykgMjAwOSBGdWppdHN1IExpbWl0ZWQuCisgKiAoYykgQ29weXJpZ2h0IDIwMDkgSGV3bGV0dC1QYWNrYXJkIERldmVsb3BtZW50IENvbXBhbnksIEwuUC4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMTQgSW50ZWwgQ29ycG9yYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorICoKKyAqIEJhc2VkIG9uIG9yaWdpbmFsIGRyaXZlcnMvcGNpL2lvYXBpYy5jCisgKglZaW5naGFpIEx1IDx5aW5naGFpQGtlcm5lbC5vcmc+CisgKglKaWFuZyBMaXUgPGppYW5nLmxpdUBpbnRlbC5jb20+CisgKi8KKworLyoKKyAqIFRoaXMgZHJpdmVyIG1hbmFnZXMgSS9PIEFQSUNzIGFkZGVkIGJ5IGhvdHBsdWcgYWZ0ZXIgYm9vdC4KKyAqIFdlIHRyeSB0byBjbGFpbSBhbGwgSS9PIEFQSUMgZGV2aWNlcywgYnV0IHRob3NlIHByZXNlbnQgYXQgYm9vdCB3ZXJlCisgKiByZWdpc3RlcmVkIHdoZW4gd2UgcGFyc2VkIHRoZSBBQ1BJIE1BRFQuCisgKi8KKworI2RlZmluZSBwcl9mbXQoZm10KSAiQUNQSSA6IElPQVBJQzogIiBmbXQKKworI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51eC9hY3BpLmg+CisjaW5jbHVkZSA8bGludXgvcGNpLmg+CisjaW5jbHVkZSA8YWNwaS9hY3BpLmg+CisKK3N0cnVjdCBhY3BpX3BjaV9pb2FwaWMgeworCWFjcGlfaGFuZGxlCXJvb3RfaGFuZGxlOworCWFjcGlfaGFuZGxlCWhhbmRsZTsKKwl1MzIJCWdzaV9iYXNlOworCXN0cnVjdCByZXNvdXJjZQlyZXM7CisJc3RydWN0IHBjaV9kZXYJKnBkZXY7CisJc3RydWN0IGxpc3RfaGVhZCBsaXN0OworfTsKKworc3RhdGljIExJU1RfSEVBRChpb2FwaWNfbGlzdCk7CitzdGF0aWMgREVGSU5FX01VVEVYKGlvYXBpY19saXN0X2xvY2spOworCitzdGF0aWMgYWNwaV9zdGF0dXMgc2V0dXBfcmVzKHN0cnVjdCBhY3BpX3Jlc291cmNlICphY3BpX3Jlcywgdm9pZCAqZGF0YSkKK3sKKwlzdHJ1Y3QgcmVzb3VyY2UgKnJlcyA9IGRhdGE7CisJc3RydWN0IHJlc291cmNlX3dpbiB3aW47CisKKwlyZXMtPmZsYWdzID0gMDsKKwlpZiAoYWNwaV9kZXZfZmlsdGVyX3Jlc291cmNlX3R5cGUoYWNwaV9yZXMsIElPUkVTT1VSQ0VfTUVNKSA9PSAwKQorCQlyZXR1cm4gQUVfT0s7CisKKwlpZiAoIWFjcGlfZGV2X3Jlc291cmNlX21lbW9yeShhY3BpX3JlcywgcmVzKSkgeworCQlpZiAoYWNwaV9kZXZfcmVzb3VyY2VfYWRkcmVzc19zcGFjZShhY3BpX3JlcywgJndpbikgfHwKKwkJICAgIGFjcGlfZGV2X3Jlc291cmNlX2V4dF9hZGRyZXNzX3NwYWNlKGFjcGlfcmVzLCAmd2luKSkKKwkJCSpyZXMgPSB3aW4ucmVzOworCX0KKwlpZiAoKHJlcy0+ZmxhZ3MgJiBJT1JFU09VUkNFX1BSRUZFVENIKSB8fAorCSAgICAocmVzLT5mbGFncyAmIElPUkVTT1VSQ0VfRElTQUJMRUQpKQorCQlyZXMtPmZsYWdzID0gMDsKKworCXJldHVybiBBRV9DVFJMX1RFUk1JTkFURTsKK30KKworc3RhdGljIGJvb2wgYWNwaV9pc19pb2FwaWMoYWNwaV9oYW5kbGUgaGFuZGxlLCBjaGFyICoqdHlwZSkKK3sKKwlhY3BpX3N0YXR1cyBzdGF0dXM7CisJc3RydWN0IGFjcGlfZGV2aWNlX2luZm8gKmluZm87CisJY2hhciAqaGlkID0gTlVMTDsKKwlib29sIG1hdGNoID0gZmFsc2U7CisKKwlpZiAoIWFjcGlfaGFzX21ldGhvZChoYW5kbGUsICJfR1NCIikpCisJCXJldHVybiBmYWxzZTsKKworCXN0YXR1cyA9IGFjcGlfZ2V0X29iamVjdF9pbmZvKGhhbmRsZSwgJmluZm8pOworCWlmIChBQ1BJX1NVQ0NFU1Moc3RhdHVzKSkgeworCQlpZiAoaW5mby0+dmFsaWQgJiBBQ1BJX1ZBTElEX0hJRCkKKwkJCWhpZCA9IGluZm8tPmhhcmR3YXJlX2lkLnN0cmluZzsKKwkJaWYgKGhpZCkgeworCQkJaWYgKHN0cmNtcChoaWQsICJBQ1BJMDAwOSIpID09IDApIHsKKwkJCQkqdHlwZSA9ICJJT3hBUElDIjsKKwkJCQltYXRjaCA9IHRydWU7CisJCQl9IGVsc2UgaWYgKHN0cmNtcChoaWQsICJBQ1BJMDAwQSIpID09IDApIHsKKwkJCQkqdHlwZSA9ICJJT0FQSUMiOworCQkJCW1hdGNoID0gdHJ1ZTsKKwkJCX0KKwkJfQorCQlrZnJlZShpbmZvKTsKKwl9CisKKwlyZXR1cm4gbWF0Y2g7Cit9CisKK3N0YXRpYyBhY3BpX3N0YXR1cyBoYW5kbGVfaW9hcGljX2FkZChhY3BpX2hhbmRsZSBoYW5kbGUsIHUzMiBsdmwsCisJCQkJICAgICB2b2lkICpjb250ZXh0LCB2b2lkICoqcnYpCit7CisJYWNwaV9zdGF0dXMgc3RhdHVzOworCXVuc2lnbmVkIGxvbmcgbG9uZyBnc2lfYmFzZTsKKwlzdHJ1Y3QgYWNwaV9wY2lfaW9hcGljICppb2FwaWM7CisJc3RydWN0IHBjaV9kZXYgKmRldiA9IE5VTEw7CisJc3RydWN0IHJlc291cmNlICpyZXMgPSBOVUxMOworCWNoYXIgKnR5cGUgPSBOVUxMOworCisJaWYgKCFhY3BpX2lzX2lvYXBpYyhoYW5kbGUsICZ0eXBlKSkKKwkJcmV0dXJuIEFFX09LOworCisJbXV0ZXhfbG9jaygmaW9hcGljX2xpc3RfbG9jayk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeShpb2FwaWMsICZpb2FwaWNfbGlzdCwgbGlzdCkKKwkJaWYgKGlvYXBpYy0+aGFuZGxlID09IGhhbmRsZSkgeworCQkJbXV0ZXhfdW5sb2NrKCZpb2FwaWNfbGlzdF9sb2NrKTsKKwkJCXJldHVybiBBRV9PSzsKKwkJfQorCisJc3RhdHVzID0gYWNwaV9ldmFsdWF0ZV9pbnRlZ2VyKGhhbmRsZSwgIl9HU0IiLCBOVUxMLCAmZ3NpX2Jhc2UpOworCWlmIChBQ1BJX0ZBSUxVUkUoc3RhdHVzKSkgeworCQlhY3BpX2hhbmRsZV93YXJuKGhhbmRsZSwgImZhaWxlZCB0byBldmFsdWF0ZSBfR1NCIG1ldGhvZFxuIik7CisJCWdvdG8gZXhpdDsKKwl9CisKKwlpb2FwaWMgPSBremFsbG9jKHNpemVvZigqaW9hcGljKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFpb2FwaWMpIHsKKwkJcHJfZXJyKCJjYW5ub3QgYWxsb2NhdGUgbWVtb3J5IGZvciBuZXcgSU9BUElDXG4iKTsKKwkJZ290byBleGl0OworCX0gZWxzZSB7CisJCWlvYXBpYy0+cm9vdF9oYW5kbGUgPSAoYWNwaV9oYW5kbGUpY29udGV4dDsKKwkJaW9hcGljLT5oYW5kbGUgPSBoYW5kbGU7CisJCWlvYXBpYy0+Z3NpX2Jhc2UgPSAodTMyKWdzaV9iYXNlOworCQlJTklUX0xJU1RfSEVBRCgmaW9hcGljLT5saXN0KTsKKwl9CisKKwlpZiAoYWNwaV9pb2FwaWNfcmVnaXN0ZXJlZChoYW5kbGUsICh1MzIpZ3NpX2Jhc2UpKQorCQlnb3RvIGRvbmU7CisKKwlkZXYgPSBhY3BpX2dldF9wY2lfZGV2KGhhbmRsZSk7CisJaWYgKGRldiAmJiBwY2lfcmVzb3VyY2VfbGVuKGRldiwgMCkpIHsKKwkJaWYgKHBjaV9lbmFibGVfZGV2aWNlKGRldikgPCAwKQorCQkJZ290byBleGl0X3B1dDsKKwkJcGNpX3NldF9tYXN0ZXIoZGV2KTsKKwkJaWYgKHBjaV9yZXF1ZXN0X3JlZ2lvbihkZXYsIDAsIHR5cGUpKQorCQkJZ290byBleGl0X2Rpc2FibGU7CisJCXJlcyA9ICZkZXYtPnJlc291cmNlWzBdOworCQlpb2FwaWMtPnBkZXYgPSBkZXY7CisJfSBlbHNlIHsKKwkJcGNpX2Rldl9wdXQoZGV2KTsKKwkJZGV2ID0gTlVMTDsKKworCQlyZXMgPSAmaW9hcGljLT5yZXM7CisJCWFjcGlfd2Fsa19yZXNvdXJjZXMoaGFuZGxlLCBNRVRIT0RfTkFNRV9fQ1JTLCBzZXR1cF9yZXMsIHJlcyk7CisJCWlmIChyZXMtPmZsYWdzID09IDApIHsKKwkJCWFjcGlfaGFuZGxlX3dhcm4oaGFuZGxlLCAiZmFpbGVkIHRvIGdldCByZXNvdXJjZVxuIik7CisJCQlnb3RvIGV4aXRfZnJlZTsKKwkJfSBlbHNlIGlmIChyZXF1ZXN0X3Jlc291cmNlKCZpb21lbV9yZXNvdXJjZSwgcmVzKSkgeworCQkJYWNwaV9oYW5kbGVfd2FybihoYW5kbGUsICJmYWlsZWQgdG8gaW5zZXJ0IHJlc291cmNlXG4iKTsKKwkJCWdvdG8gZXhpdF9mcmVlOworCQl9CisJfQorCisJaWYgKGFjcGlfcmVnaXN0ZXJfaW9hcGljKGhhbmRsZSwgcmVzLT5zdGFydCwgKHUzMilnc2lfYmFzZSkpIHsKKwkJYWNwaV9oYW5kbGVfd2FybihoYW5kbGUsICJmYWlsZWQgdG8gcmVnaXN0ZXIgSU9BUElDXG4iKTsKKwkJZ290byBleGl0X3JlbGVhc2U7CisJfQorZG9uZToKKwlsaXN0X2FkZCgmaW9hcGljLT5saXN0LCAmaW9hcGljX2xpc3QpOworCW11dGV4X3VubG9jaygmaW9hcGljX2xpc3RfbG9jayk7CisKKwlpZiAoZGV2KQorCQlkZXZfaW5mbygmZGV2LT5kZXYsICIlcyBhdCAlcFIsIEdTSSAldVxuIiwKKwkJCSB0eXBlLCByZXMsICh1MzIpZ3NpX2Jhc2UpOworCWVsc2UKKwkJYWNwaV9oYW5kbGVfaW5mbyhoYW5kbGUsICIlcyBhdCAlcFIsIEdTSSAldVxuIiwKKwkJCQkgdHlwZSwgcmVzLCAodTMyKWdzaV9iYXNlKTsKKworCXJldHVybiBBRV9PSzsKKworZXhpdF9yZWxlYXNlOgorCWlmIChkZXYpCisJCXBjaV9yZWxlYXNlX3JlZ2lvbihkZXYsIDApOworCWVsc2UKKwkJcmVsZWFzZV9yZXNvdXJjZShyZXMpOworZXhpdF9kaXNhYmxlOgorCWlmIChkZXYpCisJCXBjaV9kaXNhYmxlX2RldmljZShkZXYpOworZXhpdF9wdXQ6CisJcGNpX2Rldl9wdXQoZGV2KTsKK2V4aXRfZnJlZToKKwlrZnJlZShpb2FwaWMpOworZXhpdDoKKwltdXRleF91bmxvY2soJmlvYXBpY19saXN0X2xvY2spOworCSooYWNwaV9zdGF0dXMgKilydiA9IEFFX0VSUk9SOworCXJldHVybiBBRV9PSzsKK30KKworaW50IGFjcGlfaW9hcGljX2FkZChzdHJ1Y3QgYWNwaV9wY2lfcm9vdCAqcm9vdCkKK3sKKwlhY3BpX3N0YXR1cyBzdGF0dXMsIHJldHZhbCA9IEFFX09LOworCisJc3RhdHVzID0gYWNwaV93YWxrX25hbWVzcGFjZShBQ1BJX1RZUEVfREVWSUNFLCByb290LT5kZXZpY2UtPmhhbmRsZSwKKwkJCQkgICAgIFVJTlRfTUFYLCBoYW5kbGVfaW9hcGljX2FkZCwgTlVMTCwKKwkJCQkgICAgIHJvb3QtPmRldmljZS0+aGFuZGxlLCAodm9pZCAqKikmcmV0dmFsKTsKKworCXJldHVybiBBQ1BJX1NVQ0NFU1Moc3RhdHVzKSAmJiBBQ1BJX1NVQ0NFU1MocmV0dmFsKSA/IDAgOiAtRU5PREVWOworfQorCitpbnQgYWNwaV9pb2FwaWNfcmVtb3ZlKHN0cnVjdCBhY3BpX3BjaV9yb290ICpyb290KQoreworCWludCByZXR2YWwgPSAwOworCXN0cnVjdCBhY3BpX3BjaV9pb2FwaWMgKmlvYXBpYywgKnRtcDsKKworCW11dGV4X2xvY2soJmlvYXBpY19saXN0X2xvY2spOworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShpb2FwaWMsIHRtcCwgJmlvYXBpY19saXN0LCBsaXN0KSB7CisJCWlmIChyb290LT5kZXZpY2UtPmhhbmRsZSAhPSBpb2FwaWMtPnJvb3RfaGFuZGxlKQorCQkJY29udGludWU7CisKKwkJaWYgKGFjcGlfdW5yZWdpc3Rlcl9pb2FwaWMoaW9hcGljLT5oYW5kbGUsIGlvYXBpYy0+Z3NpX2Jhc2UpKQorCQkJcmV0dmFsID0gLUVCVVNZOworCisJCWlmIChpb2FwaWMtPnBkZXYpIHsKKwkJCXBjaV9yZWxlYXNlX3JlZ2lvbihpb2FwaWMtPnBkZXYsIDApOworCQkJcGNpX2Rpc2FibGVfZGV2aWNlKGlvYXBpYy0+cGRldik7CisJCQlwY2lfZGV2X3B1dChpb2FwaWMtPnBkZXYpOworCQl9IGVsc2UgaWYgKGlvYXBpYy0+cmVzLmZsYWdzICYmIGlvYXBpYy0+cmVzLnBhcmVudCkgeworCQkJcmVsZWFzZV9yZXNvdXJjZSgmaW9hcGljLT5yZXMpOworCQl9CisJCWxpc3RfZGVsKCZpb2FwaWMtPmxpc3QpOworCQlrZnJlZShpb2FwaWMpOworCX0KKwltdXRleF91bmxvY2soJmlvYXBpY19saXN0X2xvY2spOworCisJcmV0dXJuIHJldHZhbDsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9udW1hLmMgYi9kcml2ZXJzL2FjcGkvbnVtYS5jCmluZGV4IDI0YjU0NzYuLjEzMzNjYmRjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvbnVtYS5jCisrKyBiL2RyaXZlcnMvYWNwaS9udW1hLmMKQEAgLTE3NywxMiArMTc3LDcgQEAKIAogc3RhdGljIGludCBfX2luaXQgYWNwaV9wYXJzZV9zbGl0KHN0cnVjdCBhY3BpX3RhYmxlX2hlYWRlciAqdGFibGUpCiB7Ci0Jc3RydWN0IGFjcGlfdGFibGVfc2xpdCAqc2xpdDsKLQotCWlmICghdGFibGUpCi0JCXJldHVybiAtRUlOVkFMOwotCi0Jc2xpdCA9IChzdHJ1Y3QgYWNwaV90YWJsZV9zbGl0ICopdGFibGU7CisJc3RydWN0IGFjcGlfdGFibGVfc2xpdCAqc2xpdCA9IChzdHJ1Y3QgYWNwaV90YWJsZV9zbGl0ICopdGFibGU7CiAKIAlpZiAoIXNsaXRfdmFsaWQoc2xpdCkpIHsKIAkJcHJpbnRrKEtFUk5fSU5GTyAiQUNQSTogU0xJVCB0YWJsZSBsb29rcyBpbnZhbGlkLiBOb3QgdXNlZC5cbiIpOwpAQCAtMjYwLDExICsyNTUsOCBAQAogCiBzdGF0aWMgaW50IF9faW5pdCBhY3BpX3BhcnNlX3NyYXQoc3RydWN0IGFjcGlfdGFibGVfaGVhZGVyICp0YWJsZSkKIHsKLQlzdHJ1Y3QgYWNwaV90YWJsZV9zcmF0ICpzcmF0OwotCWlmICghdGFibGUpCi0JCXJldHVybiAtRUlOVkFMOworCXN0cnVjdCBhY3BpX3RhYmxlX3NyYXQgKnNyYXQgPSAoc3RydWN0IGFjcGlfdGFibGVfc3JhdCAqKXRhYmxlOwogCi0Jc3JhdCA9IChzdHJ1Y3QgYWNwaV90YWJsZV9zcmF0ICopdGFibGU7CiAJYWNwaV9zcmF0X3JldmlzaW9uID0gc3JhdC0+aGVhZGVyLnJldmlzaW9uOwogCiAJLyogUmVhbCB3b3JrIGRvbmUgaW4gYWNwaV90YWJsZV9wYXJzZV9zcmF0IGJlbG93LiAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL3BjaV9pcnEuYyBiL2RyaXZlcnMvYWNwaS9wY2lfaXJxLmMKaW5kZXggNTI3N2EwZS4uZTdmNzE4ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL3BjaV9pcnEuYworKysgYi9kcml2ZXJzL2FjcGkvcGNpX2lycS5jCkBAIC00ODUsMTQgKzQ4NSw2IEBACiAJaWYgKCFwaW4gfHwgIWRldi0+aXJxX21hbmFnZWQgfHwgZGV2LT5pcnEgPD0gMCkKIAkJcmV0dXJuOwogCi0JLyogS2VlcCBJT0FQSUMgcGluIGNvbmZpZ3VyYXRpb24gd2hlbiBzdXNwZW5kaW5nICovCi0JaWYgKGRldi0+ZGV2LnBvd2VyLmlzX3ByZXBhcmVkKQotCQlyZXR1cm47Ci0jaWZkZWYJQ09ORklHX1BNCi0JaWYgKGRldi0+ZGV2LnBvd2VyLnJ1bnRpbWVfc3RhdHVzID09IFJQTV9TVVNQRU5ESU5HKQotCQlyZXR1cm47Ci0jZW5kaWYKLQogCWVudHJ5ID0gYWNwaV9wY2lfaXJxX2xvb2t1cChkZXYsIHBpbik7CiAJaWYgKCFlbnRyeSkKIAkJcmV0dXJuOwpAQCAtNTEyLDcgKzUwNCw3IEBACiAJZGV2X2RiZygmZGV2LT5kZXYsICJQQ0kgSU5UICVjIGRpc2FibGVkXG4iLCBwaW5fbmFtZShwaW4pKTsKIAlpZiAoZ3NpID49IDApIHsKIAkJYWNwaV91bnJlZ2lzdGVyX2dzaShnc2kpOwotCQlkZXYtPmlycSA9IDA7CiAJCWRldi0+aXJxX21hbmFnZWQgPSAwOworCQlkZXYtPmlycSA9IDA7CiAJfQogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL3BjaV9yb290LmMgYi9kcml2ZXJzL2FjcGkvcGNpX3Jvb3QuYwppbmRleCBjNmJjYjhjLi42OGE1ZjcxIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvcGNpX3Jvb3QuYworKysgYi9kcml2ZXJzL2FjcGkvcGNpX3Jvb3QuYwpAQCAtMTEyLDEwICsxMTIsMTAgQEAKIAlpZiAoQUNQSV9GQUlMVVJFKHN0YXR1cykpCiAJCXJldHVybiBBRV9PSzsKIAotCWlmICgoYWRkcmVzcy5hZGRyZXNzX2xlbmd0aCA+IDApICYmCisJaWYgKChhZGRyZXNzLmFkZHJlc3MuYWRkcmVzc19sZW5ndGggPiAwKSAmJgogCSAgICAoYWRkcmVzcy5yZXNvdXJjZV90eXBlID09IEFDUElfQlVTX05VTUJFUl9SQU5HRSkpIHsKLQkJcmVzLT5zdGFydCA9IGFkZHJlc3MubWluaW11bTsKLQkJcmVzLT5lbmQgPSBhZGRyZXNzLm1pbmltdW0gKyBhZGRyZXNzLmFkZHJlc3NfbGVuZ3RoIC0gMTsKKwkJcmVzLT5zdGFydCA9IGFkZHJlc3MuYWRkcmVzcy5taW5pbXVtOworCQlyZXMtPmVuZCA9IGFkZHJlc3MuYWRkcmVzcy5taW5pbXVtICsgYWRkcmVzcy5hZGRyZXNzLmFkZHJlc3NfbGVuZ3RoIC0gMTsKIAl9CiAKIAlyZXR1cm4gQUVfT0s7CkBAIC02MjEsNiArNjIxLDcgQEAKIAlpZiAoaG90YWRkKSB7CiAJCXBjaWJpb3NfcmVzb3VyY2Vfc3VydmV5X2J1cyhyb290LT5idXMpOwogCQlwY2lfYXNzaWduX3VuYXNzaWduZWRfcm9vdF9idXNfcmVzb3VyY2VzKHJvb3QtPmJ1cyk7CisJCWFjcGlfaW9hcGljX2FkZChyb290KTsKIAl9CiAKIAlwY2lfbG9ja19yZXNjYW5fcmVtb3ZlKCk7CkBAIC02NDQsNiArNjQ1LDggQEAKIAogCXBjaV9zdG9wX3Jvb3RfYnVzKHJvb3QtPmJ1cyk7CiAKKwlXQVJOX09OKGFjcGlfaW9hcGljX3JlbW92ZShyb290KSk7CisKIAlkZXZpY2Vfc2V0X3J1bl93YWtlKHJvb3QtPmJ1cy0+YnJpZGdlLCBmYWxzZSk7CiAJcGNpX2FjcGlfcmVtb3ZlX2J1c19wbV9ub3RpZmllcihkZXZpY2UpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvcHJvY2Vzc29yX2NvcmUuYyBiL2RyaXZlcnMvYWNwaS9wcm9jZXNzb3JfY29yZS5jCmluZGV4IDAyZTQ4MzkuLjc5NjI2NTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9wcm9jZXNzb3JfY29yZS5jCisrKyBiL2RyaXZlcnMvYWNwaS9wcm9jZXNzb3JfY29yZS5jCkBAIC00LDYgKzQsMTAgQEAKICAqCiAgKglBbGV4IENoaWFuZyA8YWNoaWFuZ0BocC5jb20+CiAgKgktIFVuaWZpZWQgeDg2L2lhNjQgaW1wbGVtZW50YXRpb25zCisgKgorICogSS9PIEFQSUMgaG90cGx1ZyBzdXBwb3J0CisgKglZaW5naGFpIEx1IDx5aW5naGFpQGtlcm5lbC5vcmc+CisgKglKaWFuZyBMaXUgPGppYW5nLmxpdUBpbnRlbC5jb20+CiAgKi8KICNpbmNsdWRlIDxsaW51eC9leHBvcnQuaD4KICNpbmNsdWRlIDxsaW51eC9hY3BpLmg+CkBAIC0xMiw2ICsxNiwyMSBAQAogI2RlZmluZSBfQ09NUE9ORU5UCQlBQ1BJX1BST0NFU1NPUl9DT01QT05FTlQKIEFDUElfTU9EVUxFX05BTUUoInByb2Nlc3Nvcl9jb3JlIik7CiAKK3N0YXRpYyBzdHJ1Y3QgYWNwaV90YWJsZV9tYWR0ICpnZXRfbWFkdF90YWJsZSh2b2lkKQoreworCXN0YXRpYyBzdHJ1Y3QgYWNwaV90YWJsZV9tYWR0ICptYWR0OworCXN0YXRpYyBpbnQgcmVhZF9tYWR0OworCisJaWYgKCFyZWFkX21hZHQpIHsKKwkJaWYgKEFDUElfRkFJTFVSRShhY3BpX2dldF90YWJsZShBQ1BJX1NJR19NQURULCAwLAorCQkJCQkoc3RydWN0IGFjcGlfdGFibGVfaGVhZGVyICoqKSZtYWR0KSkpCisJCQltYWR0ID0gTlVMTDsKKwkJcmVhZF9tYWR0Kys7CisJfQorCisJcmV0dXJuIG1hZHQ7Cit9CisKIHN0YXRpYyBpbnQgbWFwX2xhcGljX2lkKHN0cnVjdCBhY3BpX3N1YnRhYmxlX2hlYWRlciAqZW50cnksCiAJCSB1MzIgYWNwaV9pZCwgaW50ICphcGljX2lkKQogewpAQCAtNjcsMTcgKzg2LDEwIEBACiBzdGF0aWMgaW50IG1hcF9tYWR0X2VudHJ5KGludCB0eXBlLCB1MzIgYWNwaV9pZCkKIHsKIAl1bnNpZ25lZCBsb25nIG1hZHRfZW5kLCBlbnRyeTsKLQlzdGF0aWMgc3RydWN0IGFjcGlfdGFibGVfbWFkdCAqbWFkdDsKLQlzdGF0aWMgaW50IHJlYWRfbWFkdDsKIAlpbnQgcGh5c19pZCA9IC0xOwkvKiBDUFUgaGFyZHdhcmUgSUQgKi8KKwlzdHJ1Y3QgYWNwaV90YWJsZV9tYWR0ICptYWR0OwogCi0JaWYgKCFyZWFkX21hZHQpIHsKLQkJaWYgKEFDUElfRkFJTFVSRShhY3BpX2dldF90YWJsZShBQ1BJX1NJR19NQURULCAwLAotCQkJCQkoc3RydWN0IGFjcGlfdGFibGVfaGVhZGVyICoqKSZtYWR0KSkpCi0JCQltYWR0ID0gTlVMTDsKLQkJcmVhZF9tYWR0Kys7Ci0JfQotCisJbWFkdCA9IGdldF9tYWR0X3RhYmxlKCk7CiAJaWYgKCFtYWR0KQogCQlyZXR1cm4gcGh5c19pZDsKIApAQCAtMjAzLDMgKzIxNSw5NiBAQAogCXJldHVybiBhY3BpX21hcF9jcHVpZChwaHlzX2lkLCBhY3BpX2lkKTsKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKGFjcGlfZ2V0X2NwdWlkKTsKKworI2lmZGVmIENPTkZJR19BQ1BJX0hPVFBMVUdfSU9BUElDCitzdGF0aWMgaW50IGdldF9pb2FwaWNfaWQoc3RydWN0IGFjcGlfc3VidGFibGVfaGVhZGVyICplbnRyeSwgdTMyIGdzaV9iYXNlLAorCQkJIHU2NCAqcGh5c19hZGRyLCBpbnQgKmlvYXBpY19pZCkKK3sKKwlzdHJ1Y3QgYWNwaV9tYWR0X2lvX2FwaWMgKmlvYXBpYyA9IChzdHJ1Y3QgYWNwaV9tYWR0X2lvX2FwaWMgKillbnRyeTsKKworCWlmIChpb2FwaWMtPmdsb2JhbF9pcnFfYmFzZSAhPSBnc2lfYmFzZSkKKwkJcmV0dXJuIDA7CisKKwkqcGh5c19hZGRyID0gaW9hcGljLT5hZGRyZXNzOworCSppb2FwaWNfaWQgPSBpb2FwaWMtPmlkOworCXJldHVybiAxOworfQorCitzdGF0aWMgaW50IHBhcnNlX21hZHRfaW9hcGljX2VudHJ5KHUzMiBnc2lfYmFzZSwgdTY0ICpwaHlzX2FkZHIpCit7CisJc3RydWN0IGFjcGlfc3VidGFibGVfaGVhZGVyICpoZHI7CisJdW5zaWduZWQgbG9uZyBtYWR0X2VuZCwgZW50cnk7CisJc3RydWN0IGFjcGlfdGFibGVfbWFkdCAqbWFkdDsKKwlpbnQgYXBpY19pZCA9IC0xOworCisJbWFkdCA9IGdldF9tYWR0X3RhYmxlKCk7CisJaWYgKCFtYWR0KQorCQlyZXR1cm4gYXBpY19pZDsKKworCWVudHJ5ID0gKHVuc2lnbmVkIGxvbmcpbWFkdDsKKwltYWR0X2VuZCA9IGVudHJ5ICsgbWFkdC0+aGVhZGVyLmxlbmd0aDsKKworCS8qIFBhcnNlIGFsbCBlbnRyaWVzIGxvb2tpbmcgZm9yIGEgbWF0Y2guICovCisJZW50cnkgKz0gc2l6ZW9mKHN0cnVjdCBhY3BpX3RhYmxlX21hZHQpOworCXdoaWxlIChlbnRyeSArIHNpemVvZihzdHJ1Y3QgYWNwaV9zdWJ0YWJsZV9oZWFkZXIpIDwgbWFkdF9lbmQpIHsKKwkJaGRyID0gKHN0cnVjdCBhY3BpX3N1YnRhYmxlX2hlYWRlciAqKWVudHJ5OworCQlpZiAoaGRyLT50eXBlID09IEFDUElfTUFEVF9UWVBFX0lPX0FQSUMgJiYKKwkJICAgIGdldF9pb2FwaWNfaWQoaGRyLCBnc2lfYmFzZSwgcGh5c19hZGRyLCAmYXBpY19pZCkpCisJCQlicmVhazsKKwkJZWxzZQorCQkJZW50cnkgKz0gaGRyLT5sZW5ndGg7CisJfQorCisJcmV0dXJuIGFwaWNfaWQ7Cit9CisKK3N0YXRpYyBpbnQgcGFyc2VfbWF0X2lvYXBpY19lbnRyeShhY3BpX2hhbmRsZSBoYW5kbGUsIHUzMiBnc2lfYmFzZSwKKwkJCQkgIHU2NCAqcGh5c19hZGRyKQoreworCXN0cnVjdCBhY3BpX2J1ZmZlciBidWZmZXIgPSB7IEFDUElfQUxMT0NBVEVfQlVGRkVSLCBOVUxMIH07CisJc3RydWN0IGFjcGlfc3VidGFibGVfaGVhZGVyICpoZWFkZXI7CisJdW5pb24gYWNwaV9vYmplY3QgKm9iajsKKwlpbnQgYXBpY19pZCA9IC0xOworCisJaWYgKEFDUElfRkFJTFVSRShhY3BpX2V2YWx1YXRlX29iamVjdChoYW5kbGUsICJfTUFUIiwgTlVMTCwgJmJ1ZmZlcikpKQorCQlnb3RvIGV4aXQ7CisKKwlpZiAoIWJ1ZmZlci5sZW5ndGggfHwgIWJ1ZmZlci5wb2ludGVyKQorCQlnb3RvIGV4aXQ7CisKKwlvYmogPSBidWZmZXIucG9pbnRlcjsKKwlpZiAob2JqLT50eXBlICE9IEFDUElfVFlQRV9CVUZGRVIgfHwKKwkgICAgb2JqLT5idWZmZXIubGVuZ3RoIDwgc2l6ZW9mKHN0cnVjdCBhY3BpX3N1YnRhYmxlX2hlYWRlcikpCisJCWdvdG8gZXhpdDsKKworCWhlYWRlciA9IChzdHJ1Y3QgYWNwaV9zdWJ0YWJsZV9oZWFkZXIgKilvYmotPmJ1ZmZlci5wb2ludGVyOworCWlmIChoZWFkZXItPnR5cGUgPT0gQUNQSV9NQURUX1RZUEVfSU9fQVBJQykKKwkJZ2V0X2lvYXBpY19pZChoZWFkZXIsIGdzaV9iYXNlLCBwaHlzX2FkZHIsICZhcGljX2lkKTsKKworZXhpdDoKKwlrZnJlZShidWZmZXIucG9pbnRlcik7CisJcmV0dXJuIGFwaWNfaWQ7Cit9CisKKy8qKgorICogYWNwaV9nZXRfaW9hcGljX2lkIC0gR2V0IElPQVBJQyBJRCBhbmQgcGh5c2ljYWwgYWRkcmVzcyBtYXRjaGluZyBAZ3NpX2Jhc2UKKyAqIEBoYW5kbGU6CUFDUEkgb2JqZWN0IGZvciBJT0FQSUMgZGV2aWNlCisgKiBAZ3NpX2Jhc2U6CUdTSSBiYXNlIHRvIG1hdGNoIHdpdGgKKyAqIEBwaHlzX2FkZHI6CVBvaW50ZXIgdG8gc3RvcmUgcGh5c2ljYWwgYWRkcmVzcyBvZiBtYXRjaGluZyBJT0FQSUMgcmVjb3JkCisgKgorICogV2FsayByZXNvdXJjZXMgcmV0dXJuZWQgYnkgQUNQSV9NQVQgbWV0aG9kLCB0aGVuIEFDUEkgTUFEVCB0YWJsZSwgdG8gc2VhcmNoCisgKiBmb3IgYW4gQUNQSSBJT0FQSUMgcmVjb3JkIG1hdGNoaW5nIEBnc2lfYmFzZS4KKyAqIFJldHVybiBJT0FQSUMgaWQgYW5kIHN0b3JlIHBoeXNpY2FsIGFkZHJlc3MgaW4gQHBoeXNfYWRkciBpZiBmb3VuZCBhIG1hdGNoLAorICogb3RoZXJ3aXNlIHJldHVybiA8MC4KKyAqLworaW50IGFjcGlfZ2V0X2lvYXBpY19pZChhY3BpX2hhbmRsZSBoYW5kbGUsIHUzMiBnc2lfYmFzZSwgdTY0ICpwaHlzX2FkZHIpCit7CisJaW50IGFwaWNfaWQ7CisKKwlhcGljX2lkID0gcGFyc2VfbWF0X2lvYXBpY19lbnRyeShoYW5kbGUsIGdzaV9iYXNlLCBwaHlzX2FkZHIpOworCWlmIChhcGljX2lkID09IC0xKQorCQlhcGljX2lkID0gcGFyc2VfbWFkdF9pb2FwaWNfZW50cnkoZ3NpX2Jhc2UsIHBoeXNfYWRkcik7CisKKwlyZXR1cm4gYXBpY19pZDsKK30KKyNlbmRpZiAvKiBDT05GSUdfQUNQSV9IT1RQTFVHX0lPQVBJQyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL3Byb2Nlc3Nvcl9pZGxlLmMgYi9kcml2ZXJzL2FjcGkvcHJvY2Vzc29yX2lkbGUuYwppbmRleCA4N2I3MDRlLi5jMjU2YmQ3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvcHJvY2Vzc29yX2lkbGUuYworKysgYi9kcml2ZXJzL2FjcGkvcHJvY2Vzc29yX2lkbGUuYwpAQCAtNjgxLDE1ICs2ODEsMTMgQEAKIH0KIAogLyoqCi0gKiBhY3BpX2lkbGVfZG9fZW50cnkgLSBhIGhlbHBlciBmdW5jdGlvbiB0aGF0IGRvZXMgQzIgYW5kIEMzIHR5cGUgZW50cnkKKyAqIGFjcGlfaWRsZV9kb19lbnRyeSAtIGVudGVyIGlkbGUgc3RhdGUgdXNpbmcgdGhlIGFwcHJvcHJpYXRlIG1ldGhvZAogICogQGN4OiBjc3RhdGUgZGF0YQogICoKICAqIENhbGxlciBkaXNhYmxlcyBpbnRlcnJ1cHQgYmVmb3JlIGNhbGwgYW5kIGVuYWJsZXMgaW50ZXJydXB0IGFmdGVyIHJldHVybi4KICAqLwotc3RhdGljIGlubGluZSB2b2lkIGFjcGlfaWRsZV9kb19lbnRyeShzdHJ1Y3QgYWNwaV9wcm9jZXNzb3JfY3ggKmN4KQorc3RhdGljIHZvaWQgYWNwaV9pZGxlX2RvX2VudHJ5KHN0cnVjdCBhY3BpX3Byb2Nlc3Nvcl9jeCAqY3gpCiB7Ci0JLyogRG9uJ3QgdHJhY2UgaXJxcyBvZmYgZm9yIGlkbGUgKi8KLQlzdG9wX2NyaXRpY2FsX3RpbWluZ3MoKTsKIAlpZiAoY3gtPmVudHJ5X21ldGhvZCA9PSBBQ1BJX0NTVEFURV9GRkgpIHsKIAkJLyogQ2FsbCBpbnRvIGFyY2hpdGVjdHVyYWwgRkZIIGJhc2VkIEMtc3RhdGUgKi8KIAkJYWNwaV9wcm9jZXNzb3JfZmZoX2NzdGF0ZV9lbnRlcihjeCk7CkBAIC03MDMsMzggKzcwMSw5IEBACiAJCSAgIGdldHMgYXNzZXJ0ZWQgaW4gdGltZSB0byBmcmVlemUgZXhlY3V0aW9uIHByb3Blcmx5LiAqLwogCQlpbmwoYWNwaV9nYmxfRkFEVC54cG1fdGltZXJfYmxvY2suYWRkcmVzcyk7CiAJfQotCXN0YXJ0X2NyaXRpY2FsX3RpbWluZ3MoKTsKIH0KIAogLyoqCi0gKiBhY3BpX2lkbGVfZW50ZXJfYzEgLSBlbnRlcnMgYW4gQUNQSSBDMSBzdGF0ZS10eXBlCi0gKiBAZGV2OiB0aGUgdGFyZ2V0IENQVQotICogQGRydjogY3B1aWRsZSBkcml2ZXIgY29udGFpbmluZyBjcHVpZGxlIHN0YXRlIGluZm8KLSAqIEBpbmRleDogaW5kZXggb2YgdGFyZ2V0IHN0YXRlCi0gKgotICogVGhpcyBpcyBlcXVpdmFsZW50IHRvIHRoZSBIQUxUIGluc3RydWN0aW9uLgotICovCi1zdGF0aWMgaW50IGFjcGlfaWRsZV9lbnRlcl9jMShzdHJ1Y3QgY3B1aWRsZV9kZXZpY2UgKmRldiwKLQkJc3RydWN0IGNwdWlkbGVfZHJpdmVyICpkcnYsIGludCBpbmRleCkKLXsKLQlzdHJ1Y3QgYWNwaV9wcm9jZXNzb3IgKnByOwotCXN0cnVjdCBhY3BpX3Byb2Nlc3Nvcl9jeCAqY3ggPSBwZXJfY3B1KGFjcGlfY3N0YXRlW2luZGV4XSwgZGV2LT5jcHUpOwotCi0JcHIgPSBfX3RoaXNfY3B1X3JlYWQocHJvY2Vzc29ycyk7Ci0KLQlpZiAodW5saWtlbHkoIXByKSkKLQkJcmV0dXJuIC1FSU5WQUw7Ci0KLQlsYXBpY190aW1lcl9zdGF0ZV9icm9hZGNhc3QocHIsIGN4LCAxKTsKLQlhY3BpX2lkbGVfZG9fZW50cnkoY3gpOwotCi0JbGFwaWNfdGltZXJfc3RhdGVfYnJvYWRjYXN0KHByLCBjeCwgMCk7Ci0KLQlyZXR1cm4gaW5kZXg7Ci19Ci0KLQotLyoqCiAgKiBhY3BpX2lkbGVfcGxheV9kZWFkIC0gZW50ZXJzIGFuIEFDUEkgc3RhdGUgZm9yIGxvbmctdGVybSBpZGxlIChpLmUuIG9mZi1saW5pbmcpCiAgKiBAZGV2OiB0aGUgdGFyZ2V0IENQVQogICogQGluZGV4OiB0aGUgaW5kZXggb2Ygc3VnZ2VzdGVkIHN0YXRlCkBAIC03NjEsNDcgKzczMCwxMSBAQAogCXJldHVybiAwOwogfQogCi0vKioKLSAqIGFjcGlfaWRsZV9lbnRlcl9zaW1wbGUgLSBlbnRlcnMgYW4gQUNQSSBzdGF0ZSB3aXRob3V0IEJNIGhhbmRsaW5nCi0gKiBAZGV2OiB0aGUgdGFyZ2V0IENQVQotICogQGRydjogY3B1aWRsZSBkcml2ZXIgd2l0aCBjcHVpZGxlIHN0YXRlIGluZm9ybWF0aW9uCi0gKiBAaW5kZXg6IHRoZSBpbmRleCBvZiBzdWdnZXN0ZWQgc3RhdGUKLSAqLwotc3RhdGljIGludCBhY3BpX2lkbGVfZW50ZXJfc2ltcGxlKHN0cnVjdCBjcHVpZGxlX2RldmljZSAqZGV2LAotCQlzdHJ1Y3QgY3B1aWRsZV9kcml2ZXIgKmRydiwgaW50IGluZGV4KQorc3RhdGljIGJvb2wgYWNwaV9pZGxlX2ZhbGxiYWNrX3RvX2MxKHN0cnVjdCBhY3BpX3Byb2Nlc3NvciAqcHIpCiB7Ci0Jc3RydWN0IGFjcGlfcHJvY2Vzc29yICpwcjsKLQlzdHJ1Y3QgYWNwaV9wcm9jZXNzb3JfY3ggKmN4ID0gcGVyX2NwdShhY3BpX2NzdGF0ZVtpbmRleF0sIGRldi0+Y3B1KTsKLQotCXByID0gX190aGlzX2NwdV9yZWFkKHByb2Nlc3NvcnMpOwotCi0JaWYgKHVubGlrZWx5KCFwcikpCi0JCXJldHVybiAtRUlOVkFMOwotCi0jaWZkZWYgQ09ORklHX0hPVFBMVUdfQ1BVCi0JaWYgKChjeC0+dHlwZSAhPSBBQ1BJX1NUQVRFX0MxKSAmJiAobnVtX29ubGluZV9jcHVzKCkgPiAxKSAmJgotCSAgICAhcHItPmZsYWdzLmhhc19jc3QgJiYKLQkgICAgIShhY3BpX2dibF9GQURULmZsYWdzICYgQUNQSV9GQURUX0MyX01QX1NVUFBPUlRFRCkpCi0JCXJldHVybiBhY3BpX2lkbGVfZW50ZXJfYzEoZGV2LCBkcnYsIENQVUlETEVfRFJJVkVSX1NUQVRFX1NUQVJUKTsKLSNlbmRpZgotCi0JLyoKLQkgKiBNdXN0IGJlIGRvbmUgYmVmb3JlIGJ1c21hc3RlciBkaXNhYmxlIGFzIHdlIG1pZ2h0IG5lZWQgdG8KLQkgKiBhY2Nlc3MgSFBFVCAhCi0JICovCi0JbGFwaWNfdGltZXJfc3RhdGVfYnJvYWRjYXN0KHByLCBjeCwgMSk7Ci0KLQlpZiAoY3gtPnR5cGUgPT0gQUNQSV9TVEFURV9DMykKLQkJQUNQSV9GTFVTSF9DUFVfQ0FDSEUoKTsKLQotCS8qIFRlbGwgdGhlIHNjaGVkdWxlciB0aGF0IHdlIGFyZSBnb2luZyBkZWVwLWlkbGU6ICovCi0Jc2NoZWRfY2xvY2tfaWRsZV9zbGVlcF9ldmVudCgpOwotCWFjcGlfaWRsZV9kb19lbnRyeShjeCk7Ci0KLQlzY2hlZF9jbG9ja19pZGxlX3dha2V1cF9ldmVudCgwKTsKLQotCWxhcGljX3RpbWVyX3N0YXRlX2Jyb2FkY2FzdChwciwgY3gsIDApOwotCXJldHVybiBpbmRleDsKKwlyZXR1cm4gSVNfRU5BQkxFRChDT05GSUdfSE9UUExVR19DUFUpICYmIG51bV9vbmxpbmVfY3B1cygpID4gMSAmJgorCQkhKGFjcGlfZ2JsX0ZBRFQuZmxhZ3MgJiBBQ1BJX0ZBRFRfQzJfTVBfU1VQUE9SVEVEKSAmJgorCQkhcHItPmZsYWdzLmhhc19jc3Q7CiB9CiAKIHN0YXRpYyBpbnQgYzNfY3B1X2NvdW50OwpAQCAtODA5LDQ0ICs3NDIsMTQgQEAKIAogLyoqCiAgKiBhY3BpX2lkbGVfZW50ZXJfYm0gLSBlbnRlcnMgQzMgd2l0aCBwcm9wZXIgQk0gaGFuZGxpbmcKLSAqIEBkZXY6IHRoZSB0YXJnZXQgQ1BVCi0gKiBAZHJ2OiBjcHVpZGxlIGRyaXZlciBjb250YWluaW5nIHN0YXRlIGRhdGEKLSAqIEBpbmRleDogdGhlIGluZGV4IG9mIHN1Z2dlc3RlZCBzdGF0ZQotICoKLSAqIElmIEJNIGlzIGRldGVjdGVkLCB0aGUgZGVlcGVzdCBub24tQzMgaWRsZSBzdGF0ZSBpcyBlbnRlcmVkIGluc3RlYWQuCisgKiBAcHI6IFRhcmdldCBwcm9jZXNzb3IKKyAqIEBjeDogVGFyZ2V0IHN0YXRlIGNvbnRleHQKICAqLwotc3RhdGljIGludCBhY3BpX2lkbGVfZW50ZXJfYm0oc3RydWN0IGNwdWlkbGVfZGV2aWNlICpkZXYsCi0JCXN0cnVjdCBjcHVpZGxlX2RyaXZlciAqZHJ2LCBpbnQgaW5kZXgpCitzdGF0aWMgdm9pZCBhY3BpX2lkbGVfZW50ZXJfYm0oc3RydWN0IGFjcGlfcHJvY2Vzc29yICpwciwKKwkJCSAgICAgICBzdHJ1Y3QgYWNwaV9wcm9jZXNzb3JfY3ggKmN4KQogewotCXN0cnVjdCBhY3BpX3Byb2Nlc3NvciAqcHI7Ci0Jc3RydWN0IGFjcGlfcHJvY2Vzc29yX2N4ICpjeCA9IHBlcl9jcHUoYWNwaV9jc3RhdGVbaW5kZXhdLCBkZXYtPmNwdSk7Ci0KLQlwciA9IF9fdGhpc19jcHVfcmVhZChwcm9jZXNzb3JzKTsKLQotCWlmICh1bmxpa2VseSghcHIpKQotCQlyZXR1cm4gLUVJTlZBTDsKLQotI2lmZGVmIENPTkZJR19IT1RQTFVHX0NQVQotCWlmICgoY3gtPnR5cGUgIT0gQUNQSV9TVEFURV9DMSkgJiYgKG51bV9vbmxpbmVfY3B1cygpID4gMSkgJiYKLQkgICAgIXByLT5mbGFncy5oYXNfY3N0ICYmCi0JICAgICEoYWNwaV9nYmxfRkFEVC5mbGFncyAmIEFDUElfRkFEVF9DMl9NUF9TVVBQT1JURUQpKQotCQlyZXR1cm4gYWNwaV9pZGxlX2VudGVyX2MxKGRldiwgZHJ2LCBDUFVJRExFX0RSSVZFUl9TVEFURV9TVEFSVCk7Ci0jZW5kaWYKLQotCWlmICghY3gtPmJtX3N0c19za2lwICYmIGFjcGlfaWRsZV9ibV9jaGVjaygpKSB7Ci0JCWlmIChkcnYtPnNhZmVfc3RhdGVfaW5kZXggPj0gMCkgewotCQkJcmV0dXJuIGRydi0+c3RhdGVzW2Rydi0+c2FmZV9zdGF0ZV9pbmRleF0uZW50ZXIoZGV2LAotCQkJCQkJZHJ2LCBkcnYtPnNhZmVfc3RhdGVfaW5kZXgpOwotCQl9IGVsc2UgewotCQkJYWNwaV9zYWZlX2hhbHQoKTsKLQkJCXJldHVybiAtRUJVU1k7Ci0JCX0KLQl9Ci0KIAlhY3BpX3VubGF6eV90bGIoc21wX3Byb2Nlc3Nvcl9pZCgpKTsKIAotCS8qIFRlbGwgdGhlIHNjaGVkdWxlciB0aGF0IHdlIGFyZSBnb2luZyBkZWVwLWlkbGU6ICovCi0Jc2NoZWRfY2xvY2tfaWRsZV9zbGVlcF9ldmVudCgpOwogCS8qCiAJICogTXVzdCBiZSBkb25lIGJlZm9yZSBidXNtYXN0ZXIgZGlzYWJsZSBhcyB3ZSBtaWdodCBuZWVkIHRvCiAJICogYWNjZXNzIEhQRVQgIQpAQCAtODU2LDM3ICs3NTksNzEgQEAKIAkvKgogCSAqIGRpc2FibGUgYnVzIG1hc3RlcgogCSAqIGJtX2NoZWNrIGltcGxpZXMgd2UgbmVlZCBBUkJfRElTCi0JICogIWJtX2NoZWNrIGltcGxpZXMgd2UgbmVlZCBjYWNoZSBmbHVzaAogCSAqIGJtX2NvbnRyb2wgaW1wbGllcyB3aGV0aGVyIHdlIGNhbiBkbyBBUkJfRElTCiAJICoKIAkgKiBUaGF0IGxlYXZlcyBhIGNhc2Ugd2hlcmUgYm1fY2hlY2sgaXMgc2V0IGFuZCBibV9jb250cm9sIGlzCiAJICogbm90IHNldC4gSW4gdGhhdCBjYXNlIHdlIGNhbm5vdCBkbyBtdWNoLCB3ZSBlbnRlciBDMwogCSAqIHdpdGhvdXQgZG9pbmcgYW55dGhpbmcuCiAJICovCi0JaWYgKHByLT5mbGFncy5ibV9jaGVjayAmJiBwci0+ZmxhZ3MuYm1fY29udHJvbCkgeworCWlmIChwci0+ZmxhZ3MuYm1fY29udHJvbCkgewogCQlyYXdfc3Bpbl9sb2NrKCZjM19sb2NrKTsKIAkJYzNfY3B1X2NvdW50Kys7CiAJCS8qIERpc2FibGUgYnVzIG1hc3RlciBhcmJpdHJhdGlvbiB3aGVuIGFsbCBDUFVzIGFyZSBpbiBDMyAqLwogCQlpZiAoYzNfY3B1X2NvdW50ID09IG51bV9vbmxpbmVfY3B1cygpKQogCQkJYWNwaV93cml0ZV9iaXRfcmVnaXN0ZXIoQUNQSV9CSVRSRUdfQVJCX0RJU0FCTEUsIDEpOwogCQlyYXdfc3Bpbl91bmxvY2soJmMzX2xvY2spOwotCX0gZWxzZSBpZiAoIXByLT5mbGFncy5ibV9jaGVjaykgewotCQlBQ1BJX0ZMVVNIX0NQVV9DQUNIRSgpOwogCX0KIAogCWFjcGlfaWRsZV9kb19lbnRyeShjeCk7CiAKIAkvKiBSZS1lbmFibGUgYnVzIG1hc3RlciBhcmJpdHJhdGlvbiAqLwotCWlmIChwci0+ZmxhZ3MuYm1fY2hlY2sgJiYgcHItPmZsYWdzLmJtX2NvbnRyb2wpIHsKKwlpZiAocHItPmZsYWdzLmJtX2NvbnRyb2wpIHsKIAkJcmF3X3NwaW5fbG9jaygmYzNfbG9jayk7CiAJCWFjcGlfd3JpdGVfYml0X3JlZ2lzdGVyKEFDUElfQklUUkVHX0FSQl9ESVNBQkxFLCAwKTsKIAkJYzNfY3B1X2NvdW50LS07CiAJCXJhd19zcGluX3VubG9jaygmYzNfbG9jayk7CiAJfQogCi0Jc2NoZWRfY2xvY2tfaWRsZV93YWtldXBfZXZlbnQoMCk7CisJbGFwaWNfdGltZXJfc3RhdGVfYnJvYWRjYXN0KHByLCBjeCwgMCk7Cit9CisKK3N0YXRpYyBpbnQgYWNwaV9pZGxlX2VudGVyKHN0cnVjdCBjcHVpZGxlX2RldmljZSAqZGV2LAorCQkJICAgc3RydWN0IGNwdWlkbGVfZHJpdmVyICpkcnYsIGludCBpbmRleCkKK3sKKwlzdHJ1Y3QgYWNwaV9wcm9jZXNzb3JfY3ggKmN4ID0gcGVyX2NwdShhY3BpX2NzdGF0ZVtpbmRleF0sIGRldi0+Y3B1KTsKKwlzdHJ1Y3QgYWNwaV9wcm9jZXNzb3IgKnByOworCisJcHIgPSBfX3RoaXNfY3B1X3JlYWQocHJvY2Vzc29ycyk7CisJaWYgKHVubGlrZWx5KCFwcikpCisJCXJldHVybiAtRUlOVkFMOworCisJaWYgKGN4LT50eXBlICE9IEFDUElfU1RBVEVfQzEpIHsKKwkJaWYgKGFjcGlfaWRsZV9mYWxsYmFja190b19jMShwcikpIHsKKwkJCWluZGV4ID0gQ1BVSURMRV9EUklWRVJfU1RBVEVfU1RBUlQ7CisJCQljeCA9IHBlcl9jcHUoYWNwaV9jc3RhdGVbaW5kZXhdLCBkZXYtPmNwdSk7CisJCX0gZWxzZSBpZiAoY3gtPnR5cGUgPT0gQUNQSV9TVEFURV9DMyAmJiBwci0+ZmxhZ3MuYm1fY2hlY2spIHsKKwkJCWlmIChjeC0+Ym1fc3RzX3NraXAgfHwgIWFjcGlfaWRsZV9ibV9jaGVjaygpKSB7CisJCQkJYWNwaV9pZGxlX2VudGVyX2JtKHByLCBjeCk7CisJCQkJcmV0dXJuIGluZGV4OworCQkJfSBlbHNlIGlmIChkcnYtPnNhZmVfc3RhdGVfaW5kZXggPj0gMCkgeworCQkJCWluZGV4ID0gZHJ2LT5zYWZlX3N0YXRlX2luZGV4OworCQkJCWN4ID0gcGVyX2NwdShhY3BpX2NzdGF0ZVtpbmRleF0sIGRldi0+Y3B1KTsKKwkJCX0gZWxzZSB7CisJCQkJYWNwaV9zYWZlX2hhbHQoKTsKKwkJCQlyZXR1cm4gLUVCVVNZOworCQkJfQorCQl9CisJfQorCisJbGFwaWNfdGltZXJfc3RhdGVfYnJvYWRjYXN0KHByLCBjeCwgMSk7CisKKwlpZiAoY3gtPnR5cGUgPT0gQUNQSV9TVEFURV9DMykKKwkJQUNQSV9GTFVTSF9DUFVfQ0FDSEUoKTsKKworCWFjcGlfaWRsZV9kb19lbnRyeShjeCk7CiAKIAlsYXBpY190aW1lcl9zdGF0ZV9icm9hZGNhc3QocHIsIGN4LCAwKTsKKwogCXJldHVybiBpbmRleDsKIH0KIApAQCAtOTgxLDI3ICs5MTgsMTIgQEAKIAkJc3RybmNweShzdGF0ZS0+ZGVzYywgY3gtPmRlc2MsIENQVUlETEVfREVTQ19MRU4pOwogCQlzdGF0ZS0+ZXhpdF9sYXRlbmN5ID0gY3gtPmxhdGVuY3k7CiAJCXN0YXRlLT50YXJnZXRfcmVzaWRlbmN5ID0gY3gtPmxhdGVuY3kgKiBsYXRlbmN5X2ZhY3RvcjsKKwkJc3RhdGUtPmVudGVyID0gYWNwaV9pZGxlX2VudGVyOwogCiAJCXN0YXRlLT5mbGFncyA9IDA7Ci0JCXN3aXRjaCAoY3gtPnR5cGUpIHsKLQkJCWNhc2UgQUNQSV9TVEFURV9DMToKLQotCQkJc3RhdGUtPmVudGVyID0gYWNwaV9pZGxlX2VudGVyX2MxOworCQlpZiAoY3gtPnR5cGUgPT0gQUNQSV9TVEFURV9DMSB8fCBjeC0+dHlwZSA9PSBBQ1BJX1NUQVRFX0MyKSB7CiAJCQlzdGF0ZS0+ZW50ZXJfZGVhZCA9IGFjcGlfaWRsZV9wbGF5X2RlYWQ7CiAJCQlkcnYtPnNhZmVfc3RhdGVfaW5kZXggPSBjb3VudDsKLQkJCWJyZWFrOwotCi0JCQljYXNlIEFDUElfU1RBVEVfQzI6Ci0JCQlzdGF0ZS0+ZW50ZXIgPSBhY3BpX2lkbGVfZW50ZXJfc2ltcGxlOwotCQkJc3RhdGUtPmVudGVyX2RlYWQgPSBhY3BpX2lkbGVfcGxheV9kZWFkOwotCQkJZHJ2LT5zYWZlX3N0YXRlX2luZGV4ID0gY291bnQ7Ci0JCQlicmVhazsKLQotCQkJY2FzZSBBQ1BJX1NUQVRFX0MzOgotCQkJc3RhdGUtPmVudGVyID0gcHItPmZsYWdzLmJtX2NoZWNrID8KLQkJCQkJYWNwaV9pZGxlX2VudGVyX2JtIDoKLQkJCQkJYWNwaV9pZGxlX2VudGVyX3NpbXBsZTsKLQkJCWJyZWFrOwogCQl9CiAKIAkJY291bnQrKzsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9yZXNvdXJjZS5jIGIvZHJpdmVycy9hY3BpL3Jlc291cmNlLmMKaW5kZXggNzgyYTBkMS4uNDc1MmI5OSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL3Jlc291cmNlLmMKKysrIGIvZHJpdmVycy9hY3BpL3Jlc291cmNlLmMKQEAgLTM0LDIxICszNCwzNCBAQAogI2RlZmluZSB2YWxpZF9JUlEoaSkgKHRydWUpCiAjZW5kaWYKIAotc3RhdGljIHVuc2lnbmVkIGxvbmcgYWNwaV9kZXZfbWVtcmVzb3VyY2VfZmxhZ3ModTY0IGxlbiwgdTggd3JpdGVfcHJvdGVjdCwKLQkJCQkJCWJvb2wgd2luZG93KQorc3RhdGljIGJvb2wgYWNwaV9kZXZfcmVzb3VyY2VfbGVuX3ZhbGlkKHU2NCBzdGFydCwgdTY0IGVuZCwgdTY0IGxlbiwgYm9vbCBpbykKIHsKLQl1bnNpZ25lZCBsb25nIGZsYWdzID0gSU9SRVNPVVJDRV9NRU07CisJdTY0IHJlc2xlbiA9IGVuZCAtIHN0YXJ0ICsgMTsKIAotCWlmIChsZW4gPT0gMCkKLQkJZmxhZ3MgfD0gSU9SRVNPVVJDRV9ESVNBQkxFRDsKKwkvKgorCSAqIENIRUNLTUU6IGxlbiBtaWdodCBiZSByZXF1aXJlZCB0byBjaGVjayB2ZXJzdXMgYSBtaW5pbXVtCisJICogbGVuZ3RoIGFzIHdlbGwuIDEgZm9yIGlvIGlzIGZpbmUsIGJ1dCBmb3IgbWVtb3J5IGl0IGRvZXMKKwkgKiBub3QgbWFrZSBhbnkgc2Vuc2UgYXQgYWxsLgorCSAqLworCWlmIChsZW4gJiYgcmVzbGVuICYmIHJlc2xlbiA9PSBsZW4gJiYgc3RhcnQgPD0gZW5kKQorCQlyZXR1cm4gdHJ1ZTsKKworCXByX2luZm8oIkFDUEk6IGludmFsaWQgb3IgdW5hc3NpZ25lZCByZXNvdXJjZSAlcyBbJTAxNmxseCAtICUwMTZsbHhdIGxlbmd0aCBbJTAxNmxseF1cbiIsCisJCWlvID8gImlvIiA6ICJtZW0iLCBzdGFydCwgZW5kLCBsZW4pOworCisJcmV0dXJuIGZhbHNlOworfQorCitzdGF0aWMgdm9pZCBhY3BpX2Rldl9tZW1yZXNvdXJjZV9mbGFncyhzdHJ1Y3QgcmVzb3VyY2UgKnJlcywgdTY0IGxlbiwKKwkJCQkgICAgICAgdTggd3JpdGVfcHJvdGVjdCkKK3sKKwlyZXMtPmZsYWdzID0gSU9SRVNPVVJDRV9NRU07CisKKwlpZiAoIWFjcGlfZGV2X3Jlc291cmNlX2xlbl92YWxpZChyZXMtPnN0YXJ0LCByZXMtPmVuZCwgbGVuLCBmYWxzZSkpCisJCXJlcy0+ZmxhZ3MgfD0gSU9SRVNPVVJDRV9ESVNBQkxFRCB8IElPUkVTT1VSQ0VfVU5TRVQ7CiAKIAlpZiAod3JpdGVfcHJvdGVjdCA9PSBBQ1BJX1JFQURfV1JJVEVfTUVNT1JZKQotCQlmbGFncyB8PSBJT1JFU09VUkNFX01FTV9XUklURUFCTEU7Ci0KLQlpZiAod2luZG93KQotCQlmbGFncyB8PSBJT1JFU09VUkNFX1dJTkRPVzsKLQotCXJldHVybiBmbGFnczsKKwkJcmVzLT5mbGFncyB8PSBJT1JFU09VUkNFX01FTV9XUklURUFCTEU7CiB9CiAKIHN0YXRpYyB2b2lkIGFjcGlfZGV2X2dldF9tZW1yZXNvdXJjZShzdHJ1Y3QgcmVzb3VyY2UgKnJlcywgdTY0IHN0YXJ0LCB1NjQgbGVuLApAQCAtNTYsNyArNjksNyBAQAogewogCXJlcy0+c3RhcnQgPSBzdGFydDsKIAlyZXMtPmVuZCA9IHN0YXJ0ICsgbGVuIC0gMTsKLQlyZXMtPmZsYWdzID0gYWNwaV9kZXZfbWVtcmVzb3VyY2VfZmxhZ3MobGVuLCB3cml0ZV9wcm90ZWN0LCBmYWxzZSk7CisJYWNwaV9kZXZfbWVtcmVzb3VyY2VfZmxhZ3MocmVzLCBsZW4sIHdyaXRlX3Byb3RlY3QpOwogfQogCiAvKioKQEAgLTY3LDYgKzgwLDExIEBACiAgKiBDaGVjayBpZiB0aGUgZ2l2ZW4gQUNQSSByZXNvdXJjZSBvYmplY3QgcmVwcmVzZW50cyBhIG1lbW9yeSByZXNvdXJjZSBhbmQKICAqIGlmIHRoYXQncyB0aGUgY2FzZSwgdXNlIHRoZSBpbmZvcm1hdGlvbiBpbiBpdCB0byBwb3B1bGF0ZSB0aGUgZ2VuZXJpYwogICogcmVzb3VyY2Ugb2JqZWN0IHBvaW50ZWQgdG8gYnkgQHJlcy4KKyAqCisgKiBSZXR1cm46CisgKiAxKSBmYWxzZSB3aXRoIHJlcy0+ZmxhZ3Mgc2V0dGluZyB0byB6ZXJvOiBub3QgdGhlIGV4cGVjdGVkIHJlc291cmNlIHR5cGUKKyAqIDIpIGZhbHNlIHdpdGggSU9SRVNPVVJDRV9ESVNBQkxFRCBpbiByZXMtPmZsYWdzOiB2YWxpZCB1bmFzc2lnbmVkIHJlc291cmNlCisgKiAzKSB0cnVlOiB2YWxpZCBhc3NpZ25lZCByZXNvdXJjZQogICovCiBib29sIGFjcGlfZGV2X3Jlc291cmNlX21lbW9yeShzdHJ1Y3QgYWNwaV9yZXNvdXJjZSAqYXJlcywgc3RydWN0IHJlc291cmNlICpyZXMpCiB7CkBAIC03Nyw2MCArOTUsNTIgQEAKIAlzd2l0Y2ggKGFyZXMtPnR5cGUpIHsKIAljYXNlIEFDUElfUkVTT1VSQ0VfVFlQRV9NRU1PUlkyNDoKIAkJbWVtb3J5MjQgPSAmYXJlcy0+ZGF0YS5tZW1vcnkyNDsKLQkJaWYgKCFtZW1vcnkyNC0+bWluaW11bSAmJiAhbWVtb3J5MjQtPmFkZHJlc3NfbGVuZ3RoKQotCQkJcmV0dXJuIGZhbHNlOwotCQlhY3BpX2Rldl9nZXRfbWVtcmVzb3VyY2UocmVzLCBtZW1vcnkyNC0+bWluaW11bSwKLQkJCQkJIG1lbW9yeTI0LT5hZGRyZXNzX2xlbmd0aCwKKwkJYWNwaV9kZXZfZ2V0X21lbXJlc291cmNlKHJlcywgbWVtb3J5MjQtPm1pbmltdW0gPDwgOCwKKwkJCQkJIG1lbW9yeTI0LT5hZGRyZXNzX2xlbmd0aCA8PCA4LAogCQkJCQkgbWVtb3J5MjQtPndyaXRlX3Byb3RlY3QpOwogCQlicmVhazsKIAljYXNlIEFDUElfUkVTT1VSQ0VfVFlQRV9NRU1PUlkzMjoKIAkJbWVtb3J5MzIgPSAmYXJlcy0+ZGF0YS5tZW1vcnkzMjsKLQkJaWYgKCFtZW1vcnkzMi0+bWluaW11bSAmJiAhbWVtb3J5MzItPmFkZHJlc3NfbGVuZ3RoKQotCQkJcmV0dXJuIGZhbHNlOwogCQlhY3BpX2Rldl9nZXRfbWVtcmVzb3VyY2UocmVzLCBtZW1vcnkzMi0+bWluaW11bSwKIAkJCQkJIG1lbW9yeTMyLT5hZGRyZXNzX2xlbmd0aCwKIAkJCQkJIG1lbW9yeTMyLT53cml0ZV9wcm90ZWN0KTsKIAkJYnJlYWs7CiAJY2FzZSBBQ1BJX1JFU09VUkNFX1RZUEVfRklYRURfTUVNT1JZMzI6CiAJCWZpeGVkX21lbW9yeTMyID0gJmFyZXMtPmRhdGEuZml4ZWRfbWVtb3J5MzI7Ci0JCWlmICghZml4ZWRfbWVtb3J5MzItPmFkZHJlc3MgJiYgIWZpeGVkX21lbW9yeTMyLT5hZGRyZXNzX2xlbmd0aCkKLQkJCXJldHVybiBmYWxzZTsKIAkJYWNwaV9kZXZfZ2V0X21lbXJlc291cmNlKHJlcywgZml4ZWRfbWVtb3J5MzItPmFkZHJlc3MsCiAJCQkJCSBmaXhlZF9tZW1vcnkzMi0+YWRkcmVzc19sZW5ndGgsCiAJCQkJCSBmaXhlZF9tZW1vcnkzMi0+d3JpdGVfcHJvdGVjdCk7CiAJCWJyZWFrOwogCWRlZmF1bHQ6CisJCXJlcy0+ZmxhZ3MgPSAwOwogCQlyZXR1cm4gZmFsc2U7CiAJfQotCXJldHVybiB0cnVlOworCisJcmV0dXJuICEocmVzLT5mbGFncyAmIElPUkVTT1VSQ0VfRElTQUJMRUQpOwogfQogRVhQT1JUX1NZTUJPTF9HUEwoYWNwaV9kZXZfcmVzb3VyY2VfbWVtb3J5KTsKIAotc3RhdGljIHVuc2lnbmVkIGludCBhY3BpX2Rldl9pb3Jlc291cmNlX2ZsYWdzKHU2NCBzdGFydCwgdTY0IGVuZCwgdTggaW9fZGVjb2RlLAotCQkJCQkgICAgICBib29sIHdpbmRvdykKK3N0YXRpYyB2b2lkIGFjcGlfZGV2X2lvcmVzb3VyY2VfZmxhZ3Moc3RydWN0IHJlc291cmNlICpyZXMsIHU2NCBsZW4sCisJCQkJICAgICAgdTggaW9fZGVjb2RlKQogewotCWludCBmbGFncyA9IElPUkVTT1VSQ0VfSU87CisJcmVzLT5mbGFncyA9IElPUkVTT1VSQ0VfSU87CisKKwlpZiAoIWFjcGlfZGV2X3Jlc291cmNlX2xlbl92YWxpZChyZXMtPnN0YXJ0LCByZXMtPmVuZCwgbGVuLCB0cnVlKSkKKwkJcmVzLT5mbGFncyB8PSBJT1JFU09VUkNFX0RJU0FCTEVEIHwgSU9SRVNPVVJDRV9VTlNFVDsKKworCWlmIChyZXMtPmVuZCA+PSAweDEwMDAzKQorCQlyZXMtPmZsYWdzIHw9IElPUkVTT1VSQ0VfRElTQUJMRUQgfCBJT1JFU09VUkNFX1VOU0VUOwogCiAJaWYgKGlvX2RlY29kZSA9PSBBQ1BJX0RFQ09ERV8xNikKLQkJZmxhZ3MgfD0gSU9SRVNPVVJDRV9JT18xNkJJVF9BRERSOwotCi0JaWYgKHN0YXJ0ID4gZW5kIHx8IGVuZCA+PSAweDEwMDAzKQotCQlmbGFncyB8PSBJT1JFU09VUkNFX0RJU0FCTEVEOwotCi0JaWYgKHdpbmRvdykKLQkJZmxhZ3MgfD0gSU9SRVNPVVJDRV9XSU5ET1c7Ci0KLQlyZXR1cm4gZmxhZ3M7CisJCXJlcy0+ZmxhZ3MgfD0gSU9SRVNPVVJDRV9JT18xNkJJVF9BRERSOwogfQogCiBzdGF0aWMgdm9pZCBhY3BpX2Rldl9nZXRfaW9yZXNvdXJjZShzdHJ1Y3QgcmVzb3VyY2UgKnJlcywgdTY0IHN0YXJ0LCB1NjQgbGVuLAogCQkJCSAgICB1OCBpb19kZWNvZGUpCiB7Ci0JdTY0IGVuZCA9IHN0YXJ0ICsgbGVuIC0gMTsKLQogCXJlcy0+c3RhcnQgPSBzdGFydDsKLQlyZXMtPmVuZCA9IGVuZDsKLQlyZXMtPmZsYWdzID0gYWNwaV9kZXZfaW9yZXNvdXJjZV9mbGFncyhzdGFydCwgZW5kLCBpb19kZWNvZGUsIGZhbHNlKTsKKwlyZXMtPmVuZCA9IHN0YXJ0ICsgbGVuIC0gMTsKKwlhY3BpX2Rldl9pb3Jlc291cmNlX2ZsYWdzKHJlcywgbGVuLCBpb19kZWNvZGUpOwogfQogCiAvKioKQEAgLTE0MSw2ICsxNTEsMTEgQEAKICAqIENoZWNrIGlmIHRoZSBnaXZlbiBBQ1BJIHJlc291cmNlIG9iamVjdCByZXByZXNlbnRzIGFuIEkvTyByZXNvdXJjZSBhbmQKICAqIGlmIHRoYXQncyB0aGUgY2FzZSwgdXNlIHRoZSBpbmZvcm1hdGlvbiBpbiBpdCB0byBwb3B1bGF0ZSB0aGUgZ2VuZXJpYwogICogcmVzb3VyY2Ugb2JqZWN0IHBvaW50ZWQgdG8gYnkgQHJlcy4KKyAqCisgKiBSZXR1cm46CisgKiAxKSBmYWxzZSB3aXRoIHJlcy0+ZmxhZ3Mgc2V0dGluZyB0byB6ZXJvOiBub3QgdGhlIGV4cGVjdGVkIHJlc291cmNlIHR5cGUKKyAqIDIpIGZhbHNlIHdpdGggSU9SRVNPVVJDRV9ESVNBQkxFRCBpbiByZXMtPmZsYWdzOiB2YWxpZCB1bmFzc2lnbmVkIHJlc291cmNlCisgKiAzKSB0cnVlOiB2YWxpZCBhc3NpZ25lZCByZXNvdXJjZQogICovCiBib29sIGFjcGlfZGV2X3Jlc291cmNlX2lvKHN0cnVjdCBhY3BpX3Jlc291cmNlICphcmVzLCBzdHJ1Y3QgcmVzb3VyY2UgKnJlcykKIHsKQEAgLTE1MCwxMzUgKzE2NSwxNDMgQEAKIAlzd2l0Y2ggKGFyZXMtPnR5cGUpIHsKIAljYXNlIEFDUElfUkVTT1VSQ0VfVFlQRV9JTzoKIAkJaW8gPSAmYXJlcy0+ZGF0YS5pbzsKLQkJaWYgKCFpby0+bWluaW11bSAmJiAhaW8tPmFkZHJlc3NfbGVuZ3RoKQotCQkJcmV0dXJuIGZhbHNlOwogCQlhY3BpX2Rldl9nZXRfaW9yZXNvdXJjZShyZXMsIGlvLT5taW5pbXVtLAogCQkJCQlpby0+YWRkcmVzc19sZW5ndGgsCiAJCQkJCWlvLT5pb19kZWNvZGUpOwogCQlicmVhazsKIAljYXNlIEFDUElfUkVTT1VSQ0VfVFlQRV9GSVhFRF9JTzoKIAkJZml4ZWRfaW8gPSAmYXJlcy0+ZGF0YS5maXhlZF9pbzsKLQkJaWYgKCFmaXhlZF9pby0+YWRkcmVzcyAmJiAhZml4ZWRfaW8tPmFkZHJlc3NfbGVuZ3RoKQotCQkJcmV0dXJuIGZhbHNlOwogCQlhY3BpX2Rldl9nZXRfaW9yZXNvdXJjZShyZXMsIGZpeGVkX2lvLT5hZGRyZXNzLAogCQkJCQlmaXhlZF9pby0+YWRkcmVzc19sZW5ndGgsCiAJCQkJCUFDUElfREVDT0RFXzEwKTsKIAkJYnJlYWs7CiAJZGVmYXVsdDoKKwkJcmVzLT5mbGFncyA9IDA7CiAJCXJldHVybiBmYWxzZTsKIAl9Ci0JcmV0dXJuIHRydWU7CisKKwlyZXR1cm4gIShyZXMtPmZsYWdzICYgSU9SRVNPVVJDRV9ESVNBQkxFRCk7CiB9CiBFWFBPUlRfU1lNQk9MX0dQTChhY3BpX2Rldl9yZXNvdXJjZV9pbyk7CiAKLS8qKgotICogYWNwaV9kZXZfcmVzb3VyY2VfYWRkcmVzc19zcGFjZSAtIEV4dHJhY3QgQUNQSSBhZGRyZXNzIHNwYWNlIGluZm9ybWF0aW9uLgotICogQGFyZXM6IElucHV0IEFDUEkgcmVzb3VyY2Ugb2JqZWN0LgotICogQHJlczogT3V0cHV0IGdlbmVyaWMgcmVzb3VyY2Ugb2JqZWN0LgotICoKLSAqIENoZWNrIGlmIHRoZSBnaXZlbiBBQ1BJIHJlc291cmNlIG9iamVjdCByZXByZXNlbnRzIGFuIGFkZHJlc3Mgc3BhY2UgcmVzb3VyY2UKLSAqIGFuZCBpZiB0aGF0J3MgdGhlIGNhc2UsIHVzZSB0aGUgaW5mb3JtYXRpb24gaW4gaXQgdG8gcG9wdWxhdGUgdGhlIGdlbmVyaWMKLSAqIHJlc291cmNlIG9iamVjdCBwb2ludGVkIHRvIGJ5IEByZXMuCi0gKi8KLWJvb2wgYWNwaV9kZXZfcmVzb3VyY2VfYWRkcmVzc19zcGFjZShzdHJ1Y3QgYWNwaV9yZXNvdXJjZSAqYXJlcywKLQkJCQkgICAgIHN0cnVjdCByZXNvdXJjZSAqcmVzKQorc3RhdGljIGJvb2wgYWNwaV9kZWNvZGVfc3BhY2Uoc3RydWN0IHJlc291cmNlX3dpbiAqd2luLAorCQkJICAgICAgc3RydWN0IGFjcGlfcmVzb3VyY2VfYWRkcmVzcyAqYWRkciwKKwkJCSAgICAgIHN0cnVjdCBhY3BpX2FkZHJlc3M2NF9hdHRyaWJ1dGUgKmF0dHIpCiB7Ci0JYWNwaV9zdGF0dXMgc3RhdHVzOwotCXN0cnVjdCBhY3BpX3Jlc291cmNlX2FkZHJlc3M2NCBhZGRyOwotCWJvb2wgd2luZG93OwotCXU2NCBsZW47Ci0JdTggaW9fZGVjb2RlOworCXU4IGlvZGVjID0gYXR0ci0+Z3JhbnVsYXJpdHkgPT0gMHhmZmYgPyBBQ1BJX0RFQ09ERV8xMCA6IEFDUElfREVDT0RFXzE2OworCWJvb2wgd3AgPSBhZGRyLT5pbmZvLm1lbS53cml0ZV9wcm90ZWN0OworCXU2NCBsZW4gPSBhdHRyLT5hZGRyZXNzX2xlbmd0aDsKKwlzdHJ1Y3QgcmVzb3VyY2UgKnJlcyA9ICZ3aW4tPnJlczsKIAotCXN3aXRjaCAoYXJlcy0+dHlwZSkgewotCWNhc2UgQUNQSV9SRVNPVVJDRV9UWVBFX0FERFJFU1MxNjoKLQljYXNlIEFDUElfUkVTT1VSQ0VfVFlQRV9BRERSRVNTMzI6Ci0JY2FzZSBBQ1BJX1JFU09VUkNFX1RZUEVfQUREUkVTUzY0OgotCQlicmVhazsKLQlkZWZhdWx0OgotCQlyZXR1cm4gZmFsc2U7CisJLyoKKwkgKiBGaWx0ZXIgb3V0IGludmFsaWQgZGVzY3JpcHRvciBhY2NvcmRpbmcgdG8gQUNQSSBTcGVjIDUuMCwgc2VjdGlvbgorCSAqIDYuNC4zLjUgQWRkcmVzcyBTcGFjZSBSZXNvdXJjZSBEZXNjcmlwdG9ycy4KKwkgKi8KKwlpZiAoKGFkZHItPm1pbl9hZGRyZXNzX2ZpeGVkICE9IGFkZHItPm1heF9hZGRyZXNzX2ZpeGVkICYmIGxlbikgfHwKKwkgICAgKGFkZHItPm1pbl9hZGRyZXNzX2ZpeGVkICYmIGFkZHItPm1heF9hZGRyZXNzX2ZpeGVkICYmICFsZW4pKQorCQlwcl9kZWJ1ZygiQUNQSTogSW52YWxpZCBhZGRyZXNzIHNwYWNlIG1pbl9hZGRyX2ZpeCAlZCwgbWF4X2FkZHJfZml4ICVkLCBsZW4gJWxseFxuIiwKKwkJCSBhZGRyLT5taW5fYWRkcmVzc19maXhlZCwgYWRkci0+bWF4X2FkZHJlc3NfZml4ZWQsIGxlbik7CisKKwlyZXMtPnN0YXJ0ID0gYXR0ci0+bWluaW11bTsKKwlyZXMtPmVuZCA9IGF0dHItPm1heGltdW07CisKKwkvKgorCSAqIEZvciBicmlkZ2VzIHRoYXQgdHJhbnNsYXRlIGFkZHJlc3NlcyBhY3Jvc3MgdGhlIGJyaWRnZSwKKwkgKiB0cmFuc2xhdGlvbl9vZmZzZXQgaXMgdGhlIG9mZnNldCB0aGF0IG11c3QgYmUgYWRkZWQgdG8gdGhlCisJICogYWRkcmVzcyBvbiB0aGUgc2Vjb25kYXJ5IHNpZGUgdG8gb2J0YWluIHRoZSBhZGRyZXNzIG9uIHRoZQorCSAqIHByaW1hcnkgc2lkZS4gTm9uLWJyaWRnZSBkZXZpY2VzIG11c3QgbGlzdCAwIGZvciBhbGwgQWRkcmVzcworCSAqIFRyYW5zbGF0aW9uIG9mZnNldCBiaXRzLgorCSAqLworCWlmIChhZGRyLT5wcm9kdWNlcl9jb25zdW1lciA9PSBBQ1BJX1BST0RVQ0VSKSB7CisJCXJlcy0+c3RhcnQgKz0gYXR0ci0+dHJhbnNsYXRpb25fb2Zmc2V0OworCQlyZXMtPmVuZCArPSBhdHRyLT50cmFuc2xhdGlvbl9vZmZzZXQ7CisJfSBlbHNlIGlmIChhdHRyLT50cmFuc2xhdGlvbl9vZmZzZXQpIHsKKwkJcHJfZGVidWcoIkFDUEk6IHRyYW5zbGF0aW9uX29mZnNldCglbGxkKSBpcyBpbnZhbGlkIGZvciBub24tYnJpZGdlIGRldmljZS5cbiIsCisJCQkgYXR0ci0+dHJhbnNsYXRpb25fb2Zmc2V0KTsKIAl9CiAKLQlzdGF0dXMgPSBhY3BpX3Jlc291cmNlX3RvX2FkZHJlc3M2NChhcmVzLCAmYWRkcik7Ci0JaWYgKEFDUElfRkFJTFVSRShzdGF0dXMpKQotCQlyZXR1cm4gZmFsc2U7Ci0KLQlyZXMtPnN0YXJ0ID0gYWRkci5taW5pbXVtOwotCXJlcy0+ZW5kID0gYWRkci5tYXhpbXVtOwotCXdpbmRvdyA9IGFkZHIucHJvZHVjZXJfY29uc3VtZXIgPT0gQUNQSV9QUk9EVUNFUjsKLQotCXN3aXRjaChhZGRyLnJlc291cmNlX3R5cGUpIHsKKwlzd2l0Y2ggKGFkZHItPnJlc291cmNlX3R5cGUpIHsKIAljYXNlIEFDUElfTUVNT1JZX1JBTkdFOgotCQlsZW4gPSBhZGRyLm1heGltdW0gLSBhZGRyLm1pbmltdW0gKyAxOwotCQlyZXMtPmZsYWdzID0gYWNwaV9kZXZfbWVtcmVzb3VyY2VfZmxhZ3MobGVuLAotCQkJCQkJYWRkci5pbmZvLm1lbS53cml0ZV9wcm90ZWN0LAotCQkJCQkJd2luZG93KTsKKwkJYWNwaV9kZXZfbWVtcmVzb3VyY2VfZmxhZ3MocmVzLCBsZW4sIHdwKTsKIAkJYnJlYWs7CiAJY2FzZSBBQ1BJX0lPX1JBTkdFOgotCQlpb19kZWNvZGUgPSBhZGRyLmdyYW51bGFyaXR5ID09IDB4ZmZmID8KLQkJCQlBQ1BJX0RFQ09ERV8xMCA6IEFDUElfREVDT0RFXzE2OwotCQlyZXMtPmZsYWdzID0gYWNwaV9kZXZfaW9yZXNvdXJjZV9mbGFncyhhZGRyLm1pbmltdW0sCi0JCQkJCQkgICAgICAgYWRkci5tYXhpbXVtLAotCQkJCQkJICAgICAgIGlvX2RlY29kZSwgd2luZG93KTsKKwkJYWNwaV9kZXZfaW9yZXNvdXJjZV9mbGFncyhyZXMsIGxlbiwgaW9kZWMpOwogCQlicmVhazsKIAljYXNlIEFDUElfQlVTX05VTUJFUl9SQU5HRToKIAkJcmVzLT5mbGFncyA9IElPUkVTT1VSQ0VfQlVTOwogCQlicmVhazsKIAlkZWZhdWx0OgotCQlyZXMtPmZsYWdzID0gMDsKKwkJcmV0dXJuIGZhbHNlOwogCX0KIAotCXJldHVybiB0cnVlOworCXdpbi0+b2Zmc2V0ID0gYXR0ci0+dHJhbnNsYXRpb25fb2Zmc2V0OworCisJaWYgKGFkZHItPnByb2R1Y2VyX2NvbnN1bWVyID09IEFDUElfUFJPRFVDRVIpCisJCXJlcy0+ZmxhZ3MgfD0gSU9SRVNPVVJDRV9XSU5ET1c7CisKKwlpZiAoYWRkci0+aW5mby5tZW0uY2FjaGluZyA9PSBBQ1BJX1BSRUZFVENIQUJMRV9NRU1PUlkpCisJCXJlcy0+ZmxhZ3MgfD0gSU9SRVNPVVJDRV9QUkVGRVRDSDsKKworCXJldHVybiAhKHJlcy0+ZmxhZ3MgJiBJT1JFU09VUkNFX0RJU0FCTEVEKTsKK30KKworLyoqCisgKiBhY3BpX2Rldl9yZXNvdXJjZV9hZGRyZXNzX3NwYWNlIC0gRXh0cmFjdCBBQ1BJIGFkZHJlc3Mgc3BhY2UgaW5mb3JtYXRpb24uCisgKiBAYXJlczogSW5wdXQgQUNQSSByZXNvdXJjZSBvYmplY3QuCisgKiBAd2luOiBPdXRwdXQgZ2VuZXJpYyByZXNvdXJjZSBvYmplY3QuCisgKgorICogQ2hlY2sgaWYgdGhlIGdpdmVuIEFDUEkgcmVzb3VyY2Ugb2JqZWN0IHJlcHJlc2VudHMgYW4gYWRkcmVzcyBzcGFjZSByZXNvdXJjZQorICogYW5kIGlmIHRoYXQncyB0aGUgY2FzZSwgdXNlIHRoZSBpbmZvcm1hdGlvbiBpbiBpdCB0byBwb3B1bGF0ZSB0aGUgZ2VuZXJpYworICogcmVzb3VyY2Ugb2JqZWN0IHBvaW50ZWQgdG8gYnkgQHdpbi4KKyAqCisgKiBSZXR1cm46CisgKiAxKSBmYWxzZSB3aXRoIHdpbi0+cmVzLmZsYWdzIHNldHRpbmcgdG8gemVybzogbm90IHRoZSBleHBlY3RlZCByZXNvdXJjZSB0eXBlCisgKiAyKSBmYWxzZSB3aXRoIElPUkVTT1VSQ0VfRElTQUJMRUQgaW4gd2luLT5yZXMuZmxhZ3M6IHZhbGlkIHVuYXNzaWduZWQKKyAqICAgIHJlc291cmNlCisgKiAzKSB0cnVlOiB2YWxpZCBhc3NpZ25lZCByZXNvdXJjZQorICovCitib29sIGFjcGlfZGV2X3Jlc291cmNlX2FkZHJlc3Nfc3BhY2Uoc3RydWN0IGFjcGlfcmVzb3VyY2UgKmFyZXMsCisJCQkJICAgICBzdHJ1Y3QgcmVzb3VyY2Vfd2luICp3aW4pCit7CisJc3RydWN0IGFjcGlfcmVzb3VyY2VfYWRkcmVzczY0IGFkZHI7CisKKwl3aW4tPnJlcy5mbGFncyA9IDA7CisJaWYgKEFDUElfRkFJTFVSRShhY3BpX3Jlc291cmNlX3RvX2FkZHJlc3M2NChhcmVzLCAmYWRkcikpKQorCQlyZXR1cm4gZmFsc2U7CisKKwlyZXR1cm4gYWNwaV9kZWNvZGVfc3BhY2Uod2luLCAoc3RydWN0IGFjcGlfcmVzb3VyY2VfYWRkcmVzcyAqKSZhZGRyLAorCQkJCSAmYWRkci5hZGRyZXNzKTsKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKGFjcGlfZGV2X3Jlc291cmNlX2FkZHJlc3Nfc3BhY2UpOwogCiAvKioKICAqIGFjcGlfZGV2X3Jlc291cmNlX2V4dF9hZGRyZXNzX3NwYWNlIC0gRXh0cmFjdCBBQ1BJIGFkZHJlc3Mgc3BhY2UgaW5mb3JtYXRpb24uCiAgKiBAYXJlczogSW5wdXQgQUNQSSByZXNvdXJjZSBvYmplY3QuCi0gKiBAcmVzOiBPdXRwdXQgZ2VuZXJpYyByZXNvdXJjZSBvYmplY3QuCisgKiBAd2luOiBPdXRwdXQgZ2VuZXJpYyByZXNvdXJjZSBvYmplY3QuCiAgKgogICogQ2hlY2sgaWYgdGhlIGdpdmVuIEFDUEkgcmVzb3VyY2Ugb2JqZWN0IHJlcHJlc2VudHMgYW4gZXh0ZW5kZWQgYWRkcmVzcyBzcGFjZQogICogcmVzb3VyY2UgYW5kIGlmIHRoYXQncyB0aGUgY2FzZSwgdXNlIHRoZSBpbmZvcm1hdGlvbiBpbiBpdCB0byBwb3B1bGF0ZSB0aGUKLSAqIGdlbmVyaWMgcmVzb3VyY2Ugb2JqZWN0IHBvaW50ZWQgdG8gYnkgQHJlcy4KKyAqIGdlbmVyaWMgcmVzb3VyY2Ugb2JqZWN0IHBvaW50ZWQgdG8gYnkgQHdpbi4KKyAqCisgKiBSZXR1cm46CisgKiAxKSBmYWxzZSB3aXRoIHdpbi0+cmVzLmZsYWdzIHNldHRpbmcgdG8gemVybzogbm90IHRoZSBleHBlY3RlZCByZXNvdXJjZSB0eXBlCisgKiAyKSBmYWxzZSB3aXRoIElPUkVTT1VSQ0VfRElTQUJMRUQgaW4gd2luLT5yZXMuZmxhZ3M6IHZhbGlkIHVuYXNzaWduZWQKKyAqICAgIHJlc291cmNlCisgKiAzKSB0cnVlOiB2YWxpZCBhc3NpZ25lZCByZXNvdXJjZQogICovCiBib29sIGFjcGlfZGV2X3Jlc291cmNlX2V4dF9hZGRyZXNzX3NwYWNlKHN0cnVjdCBhY3BpX3Jlc291cmNlICphcmVzLAotCQkJCQkgc3RydWN0IHJlc291cmNlICpyZXMpCisJCQkJCSBzdHJ1Y3QgcmVzb3VyY2Vfd2luICp3aW4pCiB7CiAJc3RydWN0IGFjcGlfcmVzb3VyY2VfZXh0ZW5kZWRfYWRkcmVzczY0ICpleHRfYWRkcjsKLQlib29sIHdpbmRvdzsKLQl1NjQgbGVuOwotCXU4IGlvX2RlY29kZTsKIAorCXdpbi0+cmVzLmZsYWdzID0gMDsKIAlpZiAoYXJlcy0+dHlwZSAhPSBBQ1BJX1JFU09VUkNFX1RZUEVfRVhURU5ERURfQUREUkVTUzY0KQogCQlyZXR1cm4gZmFsc2U7CiAKIAlleHRfYWRkciA9ICZhcmVzLT5kYXRhLmV4dF9hZGRyZXNzNjQ7CiAKLQlyZXMtPnN0YXJ0ID0gZXh0X2FkZHItPm1pbmltdW07Ci0JcmVzLT5lbmQgPSBleHRfYWRkci0+bWF4aW11bTsKLQl3aW5kb3cgPSBleHRfYWRkci0+cHJvZHVjZXJfY29uc3VtZXIgPT0gQUNQSV9QUk9EVUNFUjsKLQotCXN3aXRjaChleHRfYWRkci0+cmVzb3VyY2VfdHlwZSkgewotCWNhc2UgQUNQSV9NRU1PUllfUkFOR0U6Ci0JCWxlbiA9IGV4dF9hZGRyLT5tYXhpbXVtIC0gZXh0X2FkZHItPm1pbmltdW0gKyAxOwotCQlyZXMtPmZsYWdzID0gYWNwaV9kZXZfbWVtcmVzb3VyY2VfZmxhZ3MobGVuLAotCQkJCQlleHRfYWRkci0+aW5mby5tZW0ud3JpdGVfcHJvdGVjdCwKLQkJCQkJd2luZG93KTsKLQkJYnJlYWs7Ci0JY2FzZSBBQ1BJX0lPX1JBTkdFOgotCQlpb19kZWNvZGUgPSBleHRfYWRkci0+Z3JhbnVsYXJpdHkgPT0gMHhmZmYgPwotCQkJCUFDUElfREVDT0RFXzEwIDogQUNQSV9ERUNPREVfMTY7Ci0JCXJlcy0+ZmxhZ3MgPSBhY3BpX2Rldl9pb3Jlc291cmNlX2ZsYWdzKGV4dF9hZGRyLT5taW5pbXVtLAotCQkJCQkJICAgICAgIGV4dF9hZGRyLT5tYXhpbXVtLAotCQkJCQkJICAgICAgIGlvX2RlY29kZSwgd2luZG93KTsKLQkJYnJlYWs7Ci0JY2FzZSBBQ1BJX0JVU19OVU1CRVJfUkFOR0U6Ci0JCXJlcy0+ZmxhZ3MgPSBJT1JFU09VUkNFX0JVUzsKLQkJYnJlYWs7Ci0JZGVmYXVsdDoKLQkJcmVzLT5mbGFncyA9IDA7Ci0JfQotCi0JcmV0dXJuIHRydWU7CisJcmV0dXJuIGFjcGlfZGVjb2RlX3NwYWNlKHdpbiwgKHN0cnVjdCBhY3BpX3Jlc291cmNlX2FkZHJlc3MgKilleHRfYWRkciwKKwkJCQkgJmV4dF9hZGRyLT5hZGRyZXNzKTsKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKGFjcGlfZGV2X3Jlc291cmNlX2V4dF9hZGRyZXNzX3NwYWNlKTsKIApAQCAtMzEwLDcgKzMzMyw3IEBACiB7CiAJcmVzLT5zdGFydCA9IGdzaTsKIAlyZXMtPmVuZCA9IGdzaTsKLQlyZXMtPmZsYWdzID0gSU9SRVNPVVJDRV9JUlEgfCBJT1JFU09VUkNFX0RJU0FCTEVEOworCXJlcy0+ZmxhZ3MgPSBJT1JFU09VUkNFX0lSUSB8IElPUkVTT1VSQ0VfRElTQUJMRUQgfCBJT1JFU09VUkNFX1VOU0VUOwogfQogCiBzdGF0aWMgdm9pZCBhY3BpX2Rldl9nZXRfaXJxcmVzb3VyY2Uoc3RydWN0IHJlc291cmNlICpyZXMsIHUzMiBnc2ksCkBAIC0zNjksNiArMzkyLDExIEBACiAgKiByZXByZXNlbnRlZCBieSB0aGUgcmVzb3VyY2UgYW5kIHBvcHVsYXRlIHRoZSBnZW5lcmljIHJlc291cmNlIG9iamVjdCBwb2ludGVkCiAgKiB0byBieSBAcmVzIGFjY29yZGluZ2x5LiAgSWYgdGhlIHJlZ2lzdHJhdGlvbiBvZiB0aGUgR1NJIGlzIG5vdCBzdWNjZXNzZnVsLAogICogSU9SRVNPVVJDRV9ESVNBQkxFRCB3aWxsIGJlIHNldCBpdCB0aGF0IG9iamVjdCdzIGZsYWdzLgorICoKKyAqIFJldHVybjoKKyAqIDEpIGZhbHNlIHdpdGggcmVzLT5mbGFncyBzZXR0aW5nIHRvIHplcm86IG5vdCB0aGUgZXhwZWN0ZWQgcmVzb3VyY2UgdHlwZQorICogMikgZmFsc2Ugd2l0aCBJT1JFU09VUkNFX0RJU0FCTEVEIGluIHJlcy0+ZmxhZ3M6IHZhbGlkIHVuYXNzaWduZWQgcmVzb3VyY2UKKyAqIDMpIHRydWU6IHZhbGlkIGFzc2lnbmVkIHJlc291cmNlCiAgKi8KIGJvb2wgYWNwaV9kZXZfcmVzb3VyY2VfaW50ZXJydXB0KHN0cnVjdCBhY3BpX3Jlc291cmNlICphcmVzLCBpbnQgaW5kZXgsCiAJCQkJIHN0cnVjdCByZXNvdXJjZSAqcmVzKQpAQCAtNDAyLDYgKzQzMCw3IEBACiAJCQkJCSBleHRfaXJxLT5zaGFyYWJsZSwgZmFsc2UpOwogCQlicmVhazsKIAlkZWZhdWx0OgorCQlyZXMtPmZsYWdzID0gMDsKIAkJcmV0dXJuIGZhbHNlOwogCX0KIApAQCAtNDE1LDEyICs0NDQsNyBAQAogICovCiB2b2lkIGFjcGlfZGV2X2ZyZWVfcmVzb3VyY2VfbGlzdChzdHJ1Y3QgbGlzdF9oZWFkICpsaXN0KQogewotCXN0cnVjdCByZXNvdXJjZV9saXN0X2VudHJ5ICpyZW50cnksICpyZTsKLQotCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShyZW50cnksIHJlLCBsaXN0LCBub2RlKSB7Ci0JCWxpc3RfZGVsKCZyZW50cnktPm5vZGUpOwotCQlrZnJlZShyZW50cnkpOwotCX0KKwlyZXNvdXJjZV9saXN0X2ZyZWUobGlzdCk7CiB9CiBFWFBPUlRfU1lNQk9MX0dQTChhY3BpX2Rldl9mcmVlX3Jlc291cmNlX2xpc3QpOwogCkBAIC00MzIsMTggKzQ1NiwxOSBAQAogCWludCBlcnJvcjsKIH07CiAKLXN0YXRpYyBhY3BpX3N0YXR1cyBhY3BpX2Rldl9uZXdfcmVzb3VyY2VfZW50cnkoc3RydWN0IHJlc291cmNlICpyLAorc3RhdGljIGFjcGlfc3RhdHVzIGFjcGlfZGV2X25ld19yZXNvdXJjZV9lbnRyeShzdHJ1Y3QgcmVzb3VyY2Vfd2luICp3aW4sCiAJCQkJCSAgICAgICBzdHJ1Y3QgcmVzX3Byb2NfY29udGV4dCAqYykKIHsKLQlzdHJ1Y3QgcmVzb3VyY2VfbGlzdF9lbnRyeSAqcmVudHJ5OworCXN0cnVjdCByZXNvdXJjZV9lbnRyeSAqcmVudHJ5OwogCi0JcmVudHJ5ID0ga21hbGxvYyhzaXplb2YoKnJlbnRyeSksIEdGUF9LRVJORUwpOworCXJlbnRyeSA9IHJlc291cmNlX2xpc3RfY3JlYXRlX2VudHJ5KE5VTEwsIDApOwogCWlmICghcmVudHJ5KSB7CiAJCWMtPmVycm9yID0gLUVOT01FTTsKIAkJcmV0dXJuIEFFX05PX01FTU9SWTsKIAl9Ci0JcmVudHJ5LT5yZXMgPSAqcjsKLQlsaXN0X2FkZF90YWlsKCZyZW50cnktPm5vZGUsIGMtPmxpc3QpOworCSpyZW50cnktPnJlcyA9IHdpbi0+cmVzOworCXJlbnRyeS0+b2Zmc2V0ID0gd2luLT5vZmZzZXQ7CisJcmVzb3VyY2VfbGlzdF9hZGRfdGFpbChyZW50cnksIGMtPmxpc3QpOwogCWMtPmNvdW50Kys7CiAJcmV0dXJuIEFFX09LOwogfQpAQCAtNDUyLDcgKzQ3Nyw4IEBACiAJCQkJCSAgICAgdm9pZCAqY29udGV4dCkKIHsKIAlzdHJ1Y3QgcmVzX3Byb2NfY29udGV4dCAqYyA9IGNvbnRleHQ7Ci0Jc3RydWN0IHJlc291cmNlIHI7CisJc3RydWN0IHJlc291cmNlX3dpbiB3aW47CisJc3RydWN0IHJlc291cmNlICpyZXMgPSAmd2luLnJlczsKIAlpbnQgaTsKIAogCWlmIChjLT5wcmVwcm9jKSB7CkBAIC00NjcsMTggKzQ5MywxOCBAQAogCQl9CiAJfQogCi0JbWVtc2V0KCZyLCAwLCBzaXplb2YocikpOworCW1lbXNldCgmd2luLCAwLCBzaXplb2Yod2luKSk7CiAKLQlpZiAoYWNwaV9kZXZfcmVzb3VyY2VfbWVtb3J5KGFyZXMsICZyKQotCSAgICB8fCBhY3BpX2Rldl9yZXNvdXJjZV9pbyhhcmVzLCAmcikKLQkgICAgfHwgYWNwaV9kZXZfcmVzb3VyY2VfYWRkcmVzc19zcGFjZShhcmVzLCAmcikKLQkgICAgfHwgYWNwaV9kZXZfcmVzb3VyY2VfZXh0X2FkZHJlc3Nfc3BhY2UoYXJlcywgJnIpKQotCQlyZXR1cm4gYWNwaV9kZXZfbmV3X3Jlc291cmNlX2VudHJ5KCZyLCBjKTsKKwlpZiAoYWNwaV9kZXZfcmVzb3VyY2VfbWVtb3J5KGFyZXMsIHJlcykKKwkgICAgfHwgYWNwaV9kZXZfcmVzb3VyY2VfaW8oYXJlcywgcmVzKQorCSAgICB8fCBhY3BpX2Rldl9yZXNvdXJjZV9hZGRyZXNzX3NwYWNlKGFyZXMsICZ3aW4pCisJICAgIHx8IGFjcGlfZGV2X3Jlc291cmNlX2V4dF9hZGRyZXNzX3NwYWNlKGFyZXMsICZ3aW4pKQorCQlyZXR1cm4gYWNwaV9kZXZfbmV3X3Jlc291cmNlX2VudHJ5KCZ3aW4sIGMpOwogCi0JZm9yIChpID0gMDsgYWNwaV9kZXZfcmVzb3VyY2VfaW50ZXJydXB0KGFyZXMsIGksICZyKTsgaSsrKSB7CisJZm9yIChpID0gMDsgYWNwaV9kZXZfcmVzb3VyY2VfaW50ZXJydXB0KGFyZXMsIGksIHJlcyk7IGkrKykgewogCQlhY3BpX3N0YXR1cyBzdGF0dXM7CiAKLQkJc3RhdHVzID0gYWNwaV9kZXZfbmV3X3Jlc291cmNlX2VudHJ5KCZyLCBjKTsKKwkJc3RhdHVzID0gYWNwaV9kZXZfbmV3X3Jlc291cmNlX2VudHJ5KCZ3aW4sIGMpOwogCQlpZiAoQUNQSV9GQUlMVVJFKHN0YXR1cykpCiAJCQlyZXR1cm4gc3RhdHVzOwogCX0KQEAgLTUwMyw3ICs1MjksNyBAQAogICogcmV0dXJuZWQgYXMgdGhlIGZpbmFsIGVycm9yIGNvZGUuCiAgKgogICogVGhlIHJlc3VsdGFudCBzdHJ1Y3QgcmVzb3VyY2Ugb2JqZWN0cyBhcmUgcHV0IG9uIHRoZSBsaXN0IHBvaW50ZWQgdG8gYnkKLSAqIEBsaXN0LCB0aGF0IG11c3QgYmUgZW1wdHkgaW5pdGlhbGx5LCBhcyBtZW1iZXJzIG9mIHN0cnVjdCByZXNvdXJjZV9saXN0X2VudHJ5CisgKiBAbGlzdCwgdGhhdCBtdXN0IGJlIGVtcHR5IGluaXRpYWxseSwgYXMgbWVtYmVycyBvZiBzdHJ1Y3QgcmVzb3VyY2VfZW50cnkKICAqIG9iamVjdHMuICBDYWxsZXJzIG9mIHRoaXMgcm91dGluZSBzaG91bGQgdXNlICVhY3BpX2Rldl9mcmVlX3Jlc291cmNlX2xpc3QoKSB0bwogICogZnJlZSB0aGF0IGxpc3QuCiAgKgpAQCAtNTM4LDMgKzU2NCw1OCBAQAogCXJldHVybiBjLmNvdW50OwogfQogRVhQT1JUX1NZTUJPTF9HUEwoYWNwaV9kZXZfZ2V0X3Jlc291cmNlcyk7CisKKy8qKgorICogYWNwaV9kZXZfZmlsdGVyX3Jlc291cmNlX3R5cGUgLSBGaWx0ZXIgQUNQSSByZXNvdXJjZSBhY2NvcmRpbmcgdG8gcmVzb3VyY2UKKyAqCQkJCSAgIHR5cGVzCisgKiBAYXJlczogSW5wdXQgQUNQSSByZXNvdXJjZSBvYmplY3QuCisgKiBAdHlwZXM6IFZhbGlkIHJlc291cmNlIHR5cGVzIG9mIElPUkVTT1VSQ0VfWFhYCisgKgorICogVGhpcyBpcyBhIGhlcGxlciBmdW5jdGlvbiB0byBzdXBwb3J0IGFjcGlfZGV2X2dldF9yZXNvdXJjZXMoKSwgd2hpY2ggZmlsdGVycworICogQUNQSSByZXNvdXJjZSBvYmplY3RzIGFjY29yZGluZyB0byByZXNvdXJjZSB0eXBlcy4KKyAqLworaW50IGFjcGlfZGV2X2ZpbHRlcl9yZXNvdXJjZV90eXBlKHN0cnVjdCBhY3BpX3Jlc291cmNlICphcmVzLAorCQkJCSAgdW5zaWduZWQgbG9uZyB0eXBlcykKK3sKKwl1bnNpZ25lZCBsb25nIHR5cGUgPSAwOworCisJc3dpdGNoIChhcmVzLT50eXBlKSB7CisJY2FzZSBBQ1BJX1JFU09VUkNFX1RZUEVfTUVNT1JZMjQ6CisJY2FzZSBBQ1BJX1JFU09VUkNFX1RZUEVfTUVNT1JZMzI6CisJY2FzZSBBQ1BJX1JFU09VUkNFX1RZUEVfRklYRURfTUVNT1JZMzI6CisJCXR5cGUgPSBJT1JFU09VUkNFX01FTTsKKwkJYnJlYWs7CisJY2FzZSBBQ1BJX1JFU09VUkNFX1RZUEVfSU86CisJY2FzZSBBQ1BJX1JFU09VUkNFX1RZUEVfRklYRURfSU86CisJCXR5cGUgPSBJT1JFU09VUkNFX0lPOworCQlicmVhazsKKwljYXNlIEFDUElfUkVTT1VSQ0VfVFlQRV9JUlE6CisJY2FzZSBBQ1BJX1JFU09VUkNFX1RZUEVfRVhURU5ERURfSVJROgorCQl0eXBlID0gSU9SRVNPVVJDRV9JUlE7CisJCWJyZWFrOworCWNhc2UgQUNQSV9SRVNPVVJDRV9UWVBFX0RNQToKKwljYXNlIEFDUElfUkVTT1VSQ0VfVFlQRV9GSVhFRF9ETUE6CisJCXR5cGUgPSBJT1JFU09VUkNFX0RNQTsKKwkJYnJlYWs7CisJY2FzZSBBQ1BJX1JFU09VUkNFX1RZUEVfR0VORVJJQ19SRUdJU1RFUjoKKwkJdHlwZSA9IElPUkVTT1VSQ0VfUkVHOworCQlicmVhazsKKwljYXNlIEFDUElfUkVTT1VSQ0VfVFlQRV9BRERSRVNTMTY6CisJY2FzZSBBQ1BJX1JFU09VUkNFX1RZUEVfQUREUkVTUzMyOgorCWNhc2UgQUNQSV9SRVNPVVJDRV9UWVBFX0FERFJFU1M2NDoKKwljYXNlIEFDUElfUkVTT1VSQ0VfVFlQRV9FWFRFTkRFRF9BRERSRVNTNjQ6CisJCWlmIChhcmVzLT5kYXRhLmFkZHJlc3MucmVzb3VyY2VfdHlwZSA9PSBBQ1BJX01FTU9SWV9SQU5HRSkKKwkJCXR5cGUgPSBJT1JFU09VUkNFX01FTTsKKwkJZWxzZSBpZiAoYXJlcy0+ZGF0YS5hZGRyZXNzLnJlc291cmNlX3R5cGUgPT0gQUNQSV9JT19SQU5HRSkKKwkJCXR5cGUgPSBJT1JFU09VUkNFX0lPOworCQllbHNlIGlmIChhcmVzLT5kYXRhLmFkZHJlc3MucmVzb3VyY2VfdHlwZSA9PQorCQkJIEFDUElfQlVTX05VTUJFUl9SQU5HRSkKKwkJCXR5cGUgPSBJT1JFU09VUkNFX0JVUzsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJYnJlYWs7CisJfQorCisJcmV0dXJuICh0eXBlICYgdHlwZXMpID8gMCA6IDE7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChhY3BpX2Rldl9maWx0ZXJfcmVzb3VyY2VfdHlwZSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvc2Nhbi5jIGIvZHJpdmVycy9hY3BpL3NjYW4uYwppbmRleCBkYzRkODk2Li5iYmNhNzgzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvc2Nhbi5jCisrKyBiL2RyaXZlcnMvYWNwaS9zY2FuLmMKQEAgLTI1NDQsNiArMjU0NCw3IEBACiAJYWNwaV9wY2lfbGlua19pbml0KCk7CiAJYWNwaV9wcm9jZXNzb3JfaW5pdCgpOwogCWFjcGlfbHBzc19pbml0KCk7CisJYWNwaV9hcGRfaW5pdCgpOwogCWFjcGlfY21vc19ydGNfaW5pdCgpOwogCWFjcGlfY29udGFpbmVyX2luaXQoKTsKIAlhY3BpX21lbW9yeV9ob3RwbHVnX2luaXQoKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9zbGVlcC5jIGIvZHJpdmVycy9hY3BpL3NsZWVwLmMKaW5kZXggOGFhOTI1NC4uN2YyNTFkZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL3NsZWVwLmMKKysrIGIvZHJpdmVycy9hY3BpL3NsZWVwLmMKQEAgLTMyMSw3ICszMjEsNyBAQAogCXt9LAogfTsKIAotc3RhdGljIHZvaWQgYWNwaV9zbGVlcF9kbWlfY2hlY2sodm9pZCkKK3N0YXRpYyB2b2lkIF9faW5pdCBhY3BpX3NsZWVwX2RtaV9jaGVjayh2b2lkKQogewogCWludCB5ZWFyOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvdmlkZW8uYyBiL2RyaXZlcnMvYWNwaS92aWRlby5jCmluZGV4IDAzMmRiNDUuLjg4YTRmOTkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS92aWRlby5jCisrKyBiL2RyaXZlcnMvYWNwaS92aWRlby5jCkBAIC01MjIsNiArNTIyLDI0IEBACiAJCURNSV9NQVRDSChETUlfUFJPRFVDVF9OQU1FLCAiMzcwUjRFLzM3MFI0Vi8zNzBSNUUvMzU3MFJFLzM3MFI1ViIpLAogCQl9LAogCX0sCisJeworCSAvKiBodHRwczovL2J1Z3ppbGxhLnJlZGhhdC5jb20vc2hvd19idWcuY2dpP2lkPTExODYwOTcgKi8KKwkgLmNhbGxiYWNrID0gdmlkZW9fZGlzYWJsZV9uYXRpdmVfYmFja2xpZ2h0LAorCSAuaWRlbnQgPSAiU0FNU1VORyAzNTcwUi8zNzBSLzQ3MFIvNDUwUi81MTBSLzQ0NTBSViIsCisJIC5tYXRjaGVzID0geworCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJTQU1TVU5HIEVMRUNUUk9OSUNTIENPLiwgTFRELiIpLAorCQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIjM1NzBSLzM3MFIvNDcwUi80NTBSLzUxMFIvNDQ1MFJWIiksCisJCX0sCisJfSwKKwl7CisJIC8qIGh0dHBzOi8vYnVnemlsbGEucmVkaGF0LmNvbS9zaG93X2J1Zy5jZ2k/aWQ9MTA5NDk0OCAqLworCSAuY2FsbGJhY2sgPSB2aWRlb19kaXNhYmxlX25hdGl2ZV9iYWNrbGlnaHQsCisJIC5pZGVudCA9ICJTQU1TVU5HIDczMFUzRS83NDBVM0UiLAorCSAubWF0Y2hlcyA9IHsKKwkJRE1JX01BVENIKERNSV9TWVNfVkVORE9SLCAiU0FNU1VORyBFTEVDVFJPTklDUyBDTy4sIExURC4iKSwKKwkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICI3MzBVM0UvNzQwVTNFIiksCisJCX0sCisJfSwKIAogCXsKIAkgLyogaHR0cHM6Ly9idWd6aWxsYS5yZWRoYXQuY29tL3Nob3dfYnVnLmNnaT9pZD0xMTYzNTc0ICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2F0YS9LY29uZmlnIGIvZHJpdmVycy9hdGEvS2NvbmZpZwppbmRleCBhM2ExMzYwLi41ZjYwMTU1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2F0YS9LY29uZmlnCisrKyBiL2RyaXZlcnMvYXRhL0tjb25maWcKQEAgLTgzNSw2ICs4MzUsNyBAQAogY29uZmlnIFBBVEFfQVQ5MQogCXRyaXN0YXRlICJQQVRBIHN1cHBvcnQgZm9yIEFUOTFTQU05MjYwIgogCWRlcGVuZHMgb24gQVJNICYmIFNPQ19BVDkxU0FNOQorCWRlcGVuZHMgb24gIUFSQ0hfTVVMVElQTEFURk9STQogCWhlbHAKIAkgIFRoaXMgb3B0aW9uIGVuYWJsZXMgc3VwcG9ydCBmb3IgSURFIGRldmljZXMgb24gdGhlIEF0bWVsIEFUOTFTQU05MjYwIFNvQy4KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hdGEvYWhjaS5jIGIvZHJpdmVycy9hdGEvYWhjaS5jCmluZGV4IDQ5ZjFlNjguLjMzYmIwNmUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYXRhL2FoY2kuYworKysgYi9kcml2ZXJzL2F0YS9haGNpLmMKQEAgLTMyNSw3ICszMjUsNiBAQAogCXsgUENJX1ZERVZJQ0UoSU5URUwsIDB4OWQwNSksIGJvYXJkX2FoY2kgfSwgLyogU3VucmlzZSBQb2ludC1MUCBSQUlEICovCiAJeyBQQ0lfVkRFVklDRShJTlRFTCwgMHg5ZDA3KSwgYm9hcmRfYWhjaSB9LCAvKiBTdW5yaXNlIFBvaW50LUxQIFJBSUQgKi8KIAl7IFBDSV9WREVWSUNFKElOVEVMLCAweGExMDMpLCBib2FyZF9haGNpIH0sIC8qIFN1bnJpc2UgUG9pbnQtSCBBSENJICovCi0JeyBQQ0lfVkRFVklDRShJTlRFTCwgMHhhMTAzKSwgYm9hcmRfYWhjaSB9LCAvKiBTdW5yaXNlIFBvaW50LUggUkFJRCAqLwogCXsgUENJX1ZERVZJQ0UoSU5URUwsIDB4YTEwNSksIGJvYXJkX2FoY2kgfSwgLyogU3VucmlzZSBQb2ludC1IIFJBSUQgKi8KIAl7IFBDSV9WREVWSUNFKElOVEVMLCAweGExMDcpLCBib2FyZF9haGNpIH0sIC8qIFN1bnJpc2UgUG9pbnQtSCBSQUlEICovCiAJeyBQQ0lfVkRFVklDRShJTlRFTCwgMHhhMTBmKSwgYm9hcmRfYWhjaSB9LCAvKiBTdW5yaXNlIFBvaW50LUggUkFJRCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hdGEvYWhjaV94Z2VuZS5jIGIvZHJpdmVycy9hdGEvYWhjaV94Z2VuZS5jCmluZGV4IGZlZWI4ZjEuLmNiY2QyMDggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYXRhL2FoY2lfeGdlbmUuYworKysgYi9kcml2ZXJzL2F0YS9haGNpX3hnZW5lLmMKQEAgLTEyNSwxMCArMTI1LDExIEBACiAgKiB4Z2VuZV9haGNpX3FjX2lzc3VlIC0gSXNzdWUgY29tbWFuZHMgdG8gdGhlIGRldmljZQogICogQHFjOiBDb21tYW5kIHRvIGlzc3VlCiAgKgotICogRHVlIHRvIEhhcmR3YXJlIGVycmF0YSBmb3IgSURFTlRJRlkgREVWSUNFIGNvbW1hbmQsIHRoZSBjb250cm9sbGVyIGNhbm5vdAotICogY2xlYXIgdGhlIEJTWSBiaXQgYWZ0ZXIgcmVjZWl2aW5nIHRoZSBQSU8gc2V0dXAgRklTLiBUaGlzIHJlc3VsdHMgaW4gdGhlIGRtYQotICogc3RhdGUgbWFjaGluZSBnb2VzIGludG8gdGhlIENNRmF0YWxFcnJvclVwZGF0ZSBzdGF0ZSBhbmQgbG9ja3MgdXAuIEJ5Ci0gKiByZXN0YXJ0aW5nIHRoZSBkbWEgZW5naW5lLCBpdCByZW1vdmVzIHRoZSBjb250cm9sbGVyIG91dCBvZiBsb2NrIHVwIHN0YXRlLgorICogRHVlIHRvIEhhcmR3YXJlIGVycmF0YSBmb3IgSURFTlRJRlkgREVWSUNFIGNvbW1hbmQgYW5kIFBBQ0tFVAorICogY29tbWFuZCBvZiBBVEFQSSBwcm90b2NvbCBzZXQsIHRoZSBjb250cm9sbGVyIGNhbm5vdCBjbGVhciB0aGUgQlNZIGJpdAorICogYWZ0ZXIgcmVjZWl2aW5nIHRoZSBQSU8gc2V0dXAgRklTLiBUaGlzIHJlc3VsdHMgaW4gdGhlIERNQSBzdGF0ZSBtYWNoaW5lCisgKiBnb2luZyBpbnRvIHRoZSBDTUZhdGFsRXJyb3JVcGRhdGUgc3RhdGUgYW5kIGxvY2tzIHVwLiBCeSByZXN0YXJ0aW5nIHRoZQorICogRE1BIGVuZ2luZSwgaXQgcmVtb3ZlcyB0aGUgY29udHJvbGxlciBvdXQgb2YgbG9jayB1cCBzdGF0ZS4KICAqLwogc3RhdGljIHVuc2lnbmVkIGludCB4Z2VuZV9haGNpX3FjX2lzc3VlKHN0cnVjdCBhdGFfcXVldWVkX2NtZCAqcWMpCiB7CkBAIC0xMzcsNyArMTM4LDggQEAKIAlzdHJ1Y3QgeGdlbmVfYWhjaV9jb250ZXh0ICpjdHggPSBocHJpdi0+cGxhdF9kYXRhOwogCWludCByYyA9IDA7CiAKLQlpZiAodW5saWtlbHkoY3R4LT5sYXN0X2NtZFthcC0+cG9ydF9ub10gPT0gQVRBX0NNRF9JRF9BVEEpKQorCWlmICh1bmxpa2VseSgoY3R4LT5sYXN0X2NtZFthcC0+cG9ydF9ub10gPT0gQVRBX0NNRF9JRF9BVEEpIHx8CisJICAgIChjdHgtPmxhc3RfY21kW2FwLT5wb3J0X25vXSA9PSBBVEFfQ01EX1BBQ0tFVCkpKQogCQl4Z2VuZV9haGNpX3Jlc3RhcnRfZW5naW5lKGFwKTsKIAogCXJjID0gYWhjaV9xY19pc3N1ZShxYyk7CkBAIC0xODgsNyArMTkwLDcgQEAKIAkgKgogCSAqIENsZWFyIHJlc2VydmVkIGJpdCA4IChERVZTTFAgYml0KSBhcyB3ZSBkb24ndCBzdXBwb3J0IERFVlNMUAogCSAqLwotCWlkW0FUQV9JRF9GRUFUVVJFX1NVUFBdICY9IH4oMSA8PCA4KTsKKwlpZFtBVEFfSURfRkVBVFVSRV9TVVBQXSAmPSBjcHVfdG9fbGUxNih+KDEgPDwgOCkpOwogCiAJcmV0dXJuIDA7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2F0YS9saWJhaGNpLmMgYi9kcml2ZXJzL2F0YS9saWJhaGNpLmMKaW5kZXggOTc2ODNlNC4uNjFhOWMwNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9hdGEvbGliYWhjaS5jCisrKyBiL2RyaXZlcnMvYXRhL2xpYmFoY2kuYwpAQCAtMjAwMyw3ICsyMDAzLDcgQEAKIAogCWRldnNscCA9IHJlYWRsKHBvcnRfbW1pbyArIFBPUlRfREVWU0xQKTsKIAlpZiAoIShkZXZzbHAgJiBQT1JUX0RFVlNMUF9EU1ApKSB7Ci0JCWRldl9lcnIoYXAtPmhvc3QtPmRldiwgInBvcnQgZG9lcyBub3Qgc3VwcG9ydCBkZXZpY2Ugc2xlZXBcbiIpOworCQlkZXZfaW5mbyhhcC0+aG9zdC0+ZGV2LCAicG9ydCBkb2VzIG5vdCBzdXBwb3J0IGRldmljZSBzbGVlcFxuIik7CiAJCXJldHVybjsKIAl9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYXRhL2xpYmF0YS1jb3JlLmMgYi9kcml2ZXJzL2F0YS9saWJhdGEtY29yZS5jCmluZGV4IDVjODRmYjUuLmQxYTA1ZjkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYXRhL2xpYmF0YS1jb3JlLmMKKysrIGIvZHJpdmVycy9hdGEvbGliYXRhLWNvcmUuYwpAQCAtNDIzMywxMCArNDIzMywzMyBAQAogCXsgIlBJT05FRVIgRFZELVJXICBEVlItMjE2RCIsCU5VTEwsCUFUQV9IT1JLQUdFX05PU0VUWEZFUiB9LAogCiAJLyogZGV2aWNlcyB0aGF0IGRvbid0IHByb3Blcmx5IGhhbmRsZSBxdWV1ZWQgVFJJTSBjb21tYW5kcyAqLwotCXsgIk1pY3Jvbl9NNTAwKiIsCQlOVUxMLAlBVEFfSE9SS0FHRV9OT19OQ1FfVFJJTSwgfSwKLQl7ICJDcnVjaWFsX0NUPz8/TTUwMFNTRCoiLAlOVUxMLAlBVEFfSE9SS0FHRV9OT19OQ1FfVFJJTSwgfSwKLQl7ICJNaWNyb25fTTU1MCoiLAkJTlVMTCwJQVRBX0hPUktBR0VfTk9fTkNRX1RSSU0sIH0sCi0JeyAiQ3J1Y2lhbF9DVCpNNTUwU1NEKiIsCU5VTEwsCUFUQV9IT1JLQUdFX05PX05DUV9UUklNLCB9LAorCXsgIk1pY3Jvbl9NWzU2XSoiLAkJTlVMTCwJQVRBX0hPUktBR0VfTk9fTkNRX1RSSU0gfAorCQkJCQkJQVRBX0hPUktBR0VfWkVST19BRlRFUl9UUklNLCB9LAorCXsgIkNydWNpYWxfQ1QqU1NEKiIsCQlOVUxMLAlBVEFfSE9SS0FHRV9OT19OQ1FfVFJJTSwgfSwKKworCS8qCisJICogQXMgZGVmaW5lZCwgdGhlIERSQVQgKERldGVybWluaXN0aWMgUmVhZCBBZnRlciBUcmltKSBhbmQgUlpBVAorCSAqIChSZXR1cm4gWmVybyBBZnRlciBUcmltKSBmbGFncyBpbiB0aGUgQVRBIENvbW1hbmQgU2V0IGFyZQorCSAqIHVucmVsaWFibGUgaW4gdGhlIHNlbnNlIHRoYXQgdGhleSBvbmx5IGRlZmluZSB3aGF0IGhhcHBlbnMgaWYKKwkgKiB0aGUgZGV2aWNlIHN1Y2Nlc3NmdWxseSBleGVjdXRlZCB0aGUgRFNNIFRSSU0gY29tbWFuZC4gVFJJTQorCSAqIGlzIG9ubHkgYWR2aXNvcnksIGhvd2V2ZXIsIGFuZCB0aGUgZGV2aWNlIGlzIGZyZWUgdG8gc2lsZW50bHkKKwkgKiBpZ25vcmUgYWxsIG9yIHBhcnRzIG9mIHRoZSByZXF1ZXN0LgorCSAqCisJICogV2hpdGVsaXN0IGRyaXZlcyB0aGF0IGFyZSBrbm93biB0byByZWxpYWJseSByZXR1cm4gemVyb2VzCisJICogYWZ0ZXIgVFJJTS4KKwkgKi8KKworCS8qCisJICogVGhlIGludGVsIDUxMCBkcml2ZSBoYXMgYnVnZ3kgRFJBVC9SWkFULiBFeHBsaWNpdGx5IGV4Y2x1ZGUKKwkgKiB0aGF0IG1vZGVsIGJlZm9yZSB3aGl0ZWxpc3RpbmcgYWxsIG90aGVyIGludGVsIFNTRHMuCisJICovCisJeyAiSU5URUwqU1NEU0MyTUgqIiwJCU5VTEwsCTAsIH0sCisKKwl7ICJJTlRFTCpTU0QqIiwgCQlOVUxMLAlBVEFfSE9SS0FHRV9aRVJPX0FGVEVSX1RSSU0sIH0sCisJeyAiU1NEKklOVEVMKiIsCQkJTlVMTCwJQVRBX0hPUktBR0VfWkVST19BRlRFUl9UUklNLCB9LAorCXsgIlNhbXN1bmcqU1NEKiIsCQlOVUxMLAlBVEFfSE9SS0FHRV9aRVJPX0FGVEVSX1RSSU0sIH0sCisJeyAiU0FNU1VORypTU0QqIiwJCU5VTEwsCUFUQV9IT1JLQUdFX1pFUk9fQUZURVJfVFJJTSwgfSwKKwl7ICJTVFsxMjQ4XVswMjQ4XTBbRkhdKiIsCU5VTEwsCUFUQV9IT1JLQUdFX1pFUk9fQUZURVJfVFJJTSwgfSwKIAogCS8qCiAJICogU29tZSBXRCBTQVRBLUkgZHJpdmVzIHNwaW4gdXAgYW5kIGRvd24gZXJyYXRpY2FsbHkgd2hlbiB0aGUgbGluawpAQCAtNDc0OCw3ICs0NzcxLDEwIEBACiAJCXJldHVybiBOVUxMOwogCiAJZm9yIChpID0gMCwgdGFnID0gYXAtPmxhc3RfdGFnICsgMTsgaSA8IG1heF9xdWV1ZTsgaSsrLCB0YWcrKykgewotCQl0YWcgPSB0YWcgPCBtYXhfcXVldWUgPyB0YWcgOiAwOworCQlpZiAoYXAtPmZsYWdzICYgQVRBX0ZMQUdfTE9XVEFHKQorCQkJdGFnID0gaTsKKwkJZWxzZQorCQkJdGFnID0gdGFnIDwgbWF4X3F1ZXVlID8gdGFnIDogMDsKIAogCQkvKiB0aGUgbGFzdCB0YWcgaXMgcmVzZXJ2ZWQgZm9yIGludGVybmFsIGNvbW1hbmQuICovCiAJCWlmICh0YWcgPT0gQVRBX1RBR19JTlRFUk5BTCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYXRhL2xpYmF0YS1laC5jIGIvZHJpdmVycy9hdGEvbGliYXRhLWVoLmMKaW5kZXggM2RiZWM4OS4uOGQwMGMyNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hdGEvbGliYXRhLWVoLmMKKysrIGIvZHJpdmVycy9hdGEvbGliYXRhLWVoLmMKQEAgLTIzODksNiArMjM4OSw3IEBACiAKIAlyZXR1cm4gTlVMTDsKIH0KK0VYUE9SVF9TWU1CT0xfR1BMKGF0YV9nZXRfY21kX2Rlc2NyaXB0KTsKIAogLyoqCiAgKglhdGFfZWhfbGlua19yZXBvcnQgLSByZXBvcnQgZXJyb3IgaGFuZGxpbmcgdG8gdXNlcgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hdGEvbGliYXRhLXNjc2kuYyBiL2RyaXZlcnMvYXRhL2xpYmF0YS1zY3NpLmMKaW5kZXggZTM2NGU4Ni4uNmFiZDE3YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hdGEvbGliYXRhLXNjc2kuYworKysgYi9kcml2ZXJzL2F0YS9saWJhdGEtc2NzaS5jCkBAIC0yNTMyLDEzICsyNTMyLDE1IEBACiAJCXJidWZbMTVdID0gbG93ZXN0X2FsaWduZWQ7CiAKIAkJaWYgKGF0YV9pZF9oYXNfdHJpbShhcmdzLT5pZCkpIHsKLQkJCXJidWZbMTRdIHw9IDB4ODA7IC8qIFRQRSAqLworCQkJcmJ1ZlsxNF0gfD0gMHg4MDsgLyogTEJQTUUgKi8KIAotCQkJaWYgKGF0YV9pZF9oYXNfemVyb19hZnRlcl90cmltKGFyZ3MtPmlkKSkKLQkJCQlyYnVmWzE0XSB8PSAweDQwOyAvKiBUUFJaICovCisJCQlpZiAoYXRhX2lkX2hhc196ZXJvX2FmdGVyX3RyaW0oYXJncy0+aWQpICYmCisJCQkgICAgZGV2LT5ob3JrYWdlICYgQVRBX0hPUktBR0VfWkVST19BRlRFUl9UUklNKSB7CisJCQkJYXRhX2Rldl9pbmZvKGRldiwgIkVuYWJsaW5nIGRpc2NhcmRfemVyb2VzX2RhdGFcbiIpOworCQkJCXJidWZbMTRdIHw9IDB4NDA7IC8qIExCUFJaICovCisJCQl9CiAJCX0KIAl9Ci0KIAlyZXR1cm4gMDsKIH0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hdGEvbGliYXRhLXNmZi5jIGIvZHJpdmVycy9hdGEvbGliYXRhLXNmZi5jCmluZGV4IGRiOTBhYTMuLjJlODZlM2IgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYXRhL2xpYmF0YS1zZmYuYworKysgYi9kcml2ZXJzL2F0YS9saWJhdGEtc2ZmLmMKQEAgLTEzMzMsNyArMTMzMywxOSBAQAogCURQUklOVEsoIkVOVEVSXG4iKTsKIAogCWNhbmNlbF9kZWxheWVkX3dvcmtfc3luYygmYXAtPnNmZl9waW9fdGFzayk7CisKKwkvKgorCSAqIFdlIHdhbm5hIHJlc2V0IHRoZSBIU00gc3RhdGUgdG8gSURMRS4gIElmIHdlIGRvIHNvIHdpdGhvdXQKKwkgKiBncmFiYmluZyB0aGUgcG9ydCBsb2NrLCBjcml0aWNhbCBzZWN0aW9ucyBwcm90ZWN0ZWQgYnkgaXQgd2hpY2gKKwkgKiBleHBlY3QgdGhlIEhTTSBzdGF0ZSB0byBzdGF5IHN0YWJsZSBtYXkgZ2V0IHN1cnByaXNlZC4gIEZvcgorCSAqIGV4YW1wbGUsIHdlIG1heSBzZXQgSURMRSBpbiBiZXR3ZWVuIHRoZSB0aW1lCisJICogX19hdGFfc2ZmX3BvcnRfaW50cigpIGNoZWNrcyBmb3IgSFNNX1NUX0lETEUgYW5kIGJlZm9yZSBpdCBjYWxscworCSAqIGF0YV9zZmZfaHNtX21vdmUoKSBjYXVzaW5nIGF0YV9zZmZfaHNtX21vdmUoKSB0byBCVUcoKS4KKwkgKi8KKwlzcGluX2xvY2tfaXJxKGFwLT5sb2NrKTsKIAlhcC0+aHNtX3Rhc2tfc3RhdGUgPSBIU01fU1RfSURMRTsKKwlzcGluX3VubG9ja19pcnEoYXAtPmxvY2spOworCiAJYXAtPnNmZl9waW9fdGFza19saW5rID0gTlVMTDsKIAogCWlmIChhdGFfbXNnX2N0bChhcCkpCmRpZmYgLS1naXQgYS9kcml2ZXJzL2F0YS9zYXRhX2R3Y180NjBleC5jIGIvZHJpdmVycy9hdGEvc2F0YV9kd2NfNDYwZXguYwppbmRleCBjN2RkZWY4Li44ZTgyNDgxNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9hdGEvc2F0YV9kd2NfNDYwZXguYworKysgYi9kcml2ZXJzL2F0YS9zYXRhX2R3Y180NjBleC5jCkBAIC03OTcsNyArNzk3LDcgQEAKIAlpZiAoZXJyKSB7CiAJCWRldl9lcnIoaG9zdF9wdnQuZHdjX2RldiwgIiVzOiBkbWFfcmVxdWVzdF9pbnRlcnJ1cHRzIHJldHVybnMiCiAJCQkiICVkXG4iLCBfX2Z1bmNfXywgZXJyKTsKLQkJZ290byBlcnJvcl9vdXQ7CisJCXJldHVybiBlcnI7CiAJfQogCiAJLyogRW5hYmUgRE1BICovCkBAIC04MDgsMTEgKzgwOCw2IEBACiAJCXNhdGFfZG1hX3JlZ3MpOwogCiAJcmV0dXJuIDA7Ci0KLWVycm9yX291dDoKLQlkbWFfZHdjX2V4aXQoaHNkZXYpOwotCi0JcmV0dXJuIGVycjsKIH0KIAogc3RhdGljIGludCBzYXRhX2R3Y19zY3JfcmVhZChzdHJ1Y3QgYXRhX2xpbmsgKmxpbmssIHVuc2lnbmVkIGludCBzY3IsIHUzMiAqdmFsKQpAQCAtMTY2Miw3ICsxNjU3LDcgQEAKIAljaGFyICp2ZXIgPSAoY2hhciAqKSZ2ZXJzaW9ucjsKIAl1OCAqYmFzZSA9IE5VTEw7CiAJaW50IGVyciA9IDA7Ci0JaW50IGlycSwgcmM7CisJaW50IGlycTsKIAlzdHJ1Y3QgYXRhX2hvc3QgKmhvc3Q7CiAJc3RydWN0IGF0YV9wb3J0X2luZm8gcGkgPSBzYXRhX2R3Y19wb3J0X2luZm9bMF07CiAJY29uc3Qgc3RydWN0IGF0YV9wb3J0X2luZm8gKnBwaVtdID0geyAmcGksIE5VTEwgfTsKQEAgLTE3MjUsNyArMTcyMCw3IEBACiAJaWYgKGlycSA9PSBOT19JUlEpIHsKIAkJZGV2X2Vycigmb2ZkZXYtPmRldiwgIm5vIFNBVEEgRE1BIGlycVxuIik7CiAJCWVyciA9IC1FTk9ERVY7Ci0JCWdvdG8gZXJyb3Jfb3V0OworCQlnb3RvIGVycm9yX2lvbWFwOwogCX0KIAogCS8qIEdldCBwaHlzaWNhbCBTQVRBIERNQSByZWdpc3RlciBiYXNlIGFkZHJlc3MgKi8KQEAgLTE3MzQsMTQgKzE3MjksMTYgQEAKIAkJZGV2X2Vycigmb2ZkZXYtPmRldiwgImlvcmVtYXAgZmFpbGVkIGZvciBBSEJETUEgcmVnaXN0ZXIiCiAJCQkiIGFkZHJlc3NcbiIpOwogCQllcnIgPSAtRU5PREVWOwotCQlnb3RvIGVycm9yX291dDsKKwkJZ290byBlcnJvcl9pb21hcDsKIAl9CiAKIAkvKiBTYXZlIGRldiBmb3IgbGF0ZXIgdXNlIGluIGRldl94eHgoKSByb3V0aW5lcyAqLwogCWhvc3RfcHZ0LmR3Y19kZXYgPSAmb2ZkZXYtPmRldjsKIAogCS8qIEluaXRpYWxpemUgQUhCIERNQUMgKi8KLQlkbWFfZHdjX2luaXQoaHNkZXYsIGlycSk7CisJZXJyID0gZG1hX2R3Y19pbml0KGhzZGV2LCBpcnEpOworCWlmIChlcnIpCisJCWdvdG8gZXJyb3JfZG1hX2lvbWFwOwogCiAJLyogRW5hYmxlIFNBVEEgSW50ZXJydXB0cyAqLwogCXNhdGFfZHdjX2VuYWJsZV9pbnRlcnJ1cHRzKGhzZGV2KTsKQEAgLTE3NTksOSArMTc1Niw4IEBACiAJICogZGV2aWNlIGRpc2NvdmVyeSBwcm9jZXNzLCBpbnZva2luZyBvdXIgcG9ydF9zdGFydCgpIGhhbmRsZXIgJgogCSAqIGVycm9yX2hhbmRsZXIoKSB0byBleGVjdXRlIGEgZHVtbXkgU29mdHJlc2V0IEVIIHNlc3Npb24KIAkgKi8KLQlyYyA9IGF0YV9ob3N0X2FjdGl2YXRlKGhvc3QsIGlycSwgc2F0YV9kd2NfaXNyLCAwLCAmc2F0YV9kd2Nfc2h0KTsKLQotCWlmIChyYyAhPSAwKQorCWVyciA9IGF0YV9ob3N0X2FjdGl2YXRlKGhvc3QsIGlycSwgc2F0YV9kd2NfaXNyLCAwLCAmc2F0YV9kd2Nfc2h0KTsKKwlpZiAoZXJyKQogCQlkZXZfZXJyKCZvZmRldi0+ZGV2LCAiZmFpbGVkIHRvIGFjdGl2YXRlIGhvc3QiKTsKIAogCWRldl9zZXRfZHJ2ZGF0YSgmb2ZkZXYtPmRldiwgaG9zdCk7CkBAIC0xNzcwLDcgKzE3NjYsOCBAQAogZXJyb3Jfb3V0OgogCS8qIEZyZWUgU0FUQSBETUEgcmVzb3VyY2VzICovCiAJZG1hX2R3Y19leGl0KGhzZGV2KTsKLQorZXJyb3JfZG1hX2lvbWFwOgorCWlvdW5tYXAoKHZvaWQgX19pb21lbSAqKWhvc3RfcHZ0LnNhdGFfZG1hX3JlZ3MpOwogZXJyb3JfaW9tYXA6CiAJaW91bm1hcChiYXNlKTsKIGVycm9yX2ttYWxsb2M6CkBAIC0xNzkxLDYgKzE3ODgsNyBAQAogCS8qIEZyZWUgU0FUQSBETUEgcmVzb3VyY2VzICovCiAJZG1hX2R3Y19leGl0KGhzZGV2KTsKIAorCWlvdW5tYXAoKHZvaWQgX19pb21lbSAqKWhvc3RfcHZ0LnNhdGFfZG1hX3JlZ3MpOwogCWlvdW5tYXAoaHNkZXYtPnJlZ19iYXNlKTsKIAlrZnJlZShoc2Rldik7CiAJa2ZyZWUoaG9zdCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2F0YS9zYXRhX3NpbDI0LmMgYi9kcml2ZXJzL2F0YS9zYXRhX3NpbDI0LmMKaW5kZXggZDgxYjIwZC4uZWE2NTU5NCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hdGEvc2F0YV9zaWwyNC5jCisrKyBiL2RyaXZlcnMvYXRhL3NhdGFfc2lsMjQuYwpAQCAtMjQ2LDcgKzI0Niw3IEBACiAJLyogaG9zdCBmbGFncyAqLwogCVNJTDI0X0NPTU1PTl9GTEFHUwk9IEFUQV9GTEFHX1NBVEEgfCBBVEFfRkxBR19QSU9fRE1BIHwKIAkJCQkgIEFUQV9GTEFHX05DUSB8IEFUQV9GTEFHX0FDUElfU0FUQSB8Ci0JCQkJICBBVEFfRkxBR19BTiB8IEFUQV9GTEFHX1BNUCwKKwkJCQkgIEFUQV9GTEFHX0FOIHwgQVRBX0ZMQUdfUE1QIHwgQVRBX0ZMQUdfTE9XVEFHLAogCVNJTDI0X0ZMQUdfUENJWF9JUlFfV09DCT0gKDEgPDwgMjQpLCAvKiBJUlEgbG9zcyBlcnJhdGEgb24gUENJLVggKi8KIAogCUlSUV9TVEFUXzRQT1JUUwkJPSAweGYsCmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jhc2UvcG93ZXIvY29tbW9uLmMgYi9kcml2ZXJzL2Jhc2UvcG93ZXIvY29tbW9uLmMKaW5kZXggYjBmMTM4OC4uZjMyYjgwMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9iYXNlL3Bvd2VyL2NvbW1vbi5jCisrKyBiL2RyaXZlcnMvYmFzZS9wb3dlci9jb21tb24uYwpAQCAtMTksOCArMTksOCBAQAogICogQGRldjogRGV2aWNlIHRvIGhhbmRsZS4KICAqCiAgKiBJZiBwb3dlci5zdWJzeXNfZGF0YSBpcyBOVUxMLCBwb2ludCBpdCB0byBhIG5ldyBvYmplY3QsIG90aGVyd2lzZSBpbmNyZW1lbnQKLSAqIGl0cyByZWZlcmVuY2UgY291bnRlci4gIFJldHVybiAxIGlmIGEgbmV3IG9iamVjdCBoYXMgYmVlbiBjcmVhdGVkLCBvdGhlcndpc2UKLSAqIHJldHVybiAwIG9yIGVycm9yIGNvZGUuCisgKiBpdHMgcmVmZXJlbmNlIGNvdW50ZXIuICBSZXR1cm4gMCBpZiBuZXcgb2JqZWN0IGhhcyBiZWVuIGNyZWF0ZWQgb3IgcmVmY291bnQKKyAqIGluY3JlYXNlZCwgb3RoZXJ3aXNlIG5lZ2F0aXZlIGVycm9yIGNvZGUuCiAgKi8KIGludCBkZXZfcG1fZ2V0X3N1YnN5c19kYXRhKHN0cnVjdCBkZXZpY2UgKmRldikKIHsKQEAgLTU2LDEzICs1NiwxMSBAQAogICogQGRldjogRGV2aWNlIHRvIGhhbmRsZS4KICAqCiAgKiBJZiB0aGUgcmVmZXJlbmNlIGNvdW50ZXIgb2YgcG93ZXIuc3Vic3lzX2RhdGEgaXMgemVybyBhZnRlciBkcm9wcGluZyB0aGUKLSAqIHJlZmVyZW5jZSwgcG93ZXIuc3Vic3lzX2RhdGEgaXMgcmVtb3ZlZC4gIFJldHVybiAxIGlmIHRoYXQgaGFwcGVucyBvciAwCi0gKiBvdGhlcndpc2UuCisgKiByZWZlcmVuY2UsIHBvd2VyLnN1YnN5c19kYXRhIGlzIHJlbW92ZWQuCiAgKi8KLWludCBkZXZfcG1fcHV0X3N1YnN5c19kYXRhKHN0cnVjdCBkZXZpY2UgKmRldikKK3ZvaWQgZGV2X3BtX3B1dF9zdWJzeXNfZGF0YShzdHJ1Y3QgZGV2aWNlICpkZXYpCiB7CiAJc3RydWN0IHBtX3N1YnN5c19kYXRhICpwc2Q7Ci0JaW50IHJldCA9IDE7CiAKIAlzcGluX2xvY2tfaXJxKCZkZXYtPnBvd2VyLmxvY2spOwogCkBAIC03MCwxOCArNjgsMTQgQEAKIAlpZiAoIXBzZCkKIAkJZ290byBvdXQ7CiAKLQlpZiAoLS1wc2QtPnJlZmNvdW50ID09IDApIHsKKwlpZiAoLS1wc2QtPnJlZmNvdW50ID09IDApCiAJCWRldi0+cG93ZXIuc3Vic3lzX2RhdGEgPSBOVUxMOwotCX0gZWxzZSB7CisJZWxzZQogCQlwc2QgPSBOVUxMOwotCQlyZXQgPSAwOwotCX0KIAogIG91dDoKIAlzcGluX3VubG9ja19pcnEoJmRldi0+cG93ZXIubG9jayk7CiAJa2ZyZWUocHNkKTsKLQotCXJldHVybiByZXQ7CiB9CiBFWFBPUlRfU1lNQk9MX0dQTChkZXZfcG1fcHV0X3N1YnN5c19kYXRhKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9iYXNlL3Bvd2VyL2RvbWFpbi5jIGIvZHJpdmVycy9iYXNlL3Bvd2VyL2RvbWFpbi5jCmluZGV4IDBkODc4MGMuLmJhNGFiYmUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYmFzZS9wb3dlci9kb21haW4uYworKysgYi9kcml2ZXJzL2Jhc2UvcG93ZXIvZG9tYWluLmMKQEAgLTM0NCwxNCArMzQ0LDcgQEAKIAlzdHJ1Y3QgZGV2aWNlICpkZXY7CiAKIAlncGRfZGF0YSA9IGNvbnRhaW5lcl9vZihuYiwgc3RydWN0IGdlbmVyaWNfcG1fZG9tYWluX2RhdGEsIG5iKTsKLQotCW11dGV4X2xvY2soJmdwZF9kYXRhLT5sb2NrKTsKIAlkZXYgPSBncGRfZGF0YS0+YmFzZS5kZXY7Ci0JaWYgKCFkZXYpIHsKLQkJbXV0ZXhfdW5sb2NrKCZncGRfZGF0YS0+bG9jayk7Ci0JCXJldHVybiBOT1RJRllfRE9ORTsKLQl9Ci0JbXV0ZXhfdW5sb2NrKCZncGRfZGF0YS0+bG9jayk7CiAKIAlmb3IgKDs7KSB7CiAJCXN0cnVjdCBnZW5lcmljX3BtX2RvbWFpbiAqZ2VucGQ7CkBAIC0xMzg0LDI1ICsxMzc3LDY2IEBACiAKICNlbmRpZiAvKiBDT05GSUdfUE1fU0xFRVAgKi8KIAotc3RhdGljIHN0cnVjdCBnZW5lcmljX3BtX2RvbWFpbl9kYXRhICpfX3BtX2dlbnBkX2FsbG9jX2Rldl9kYXRhKHN0cnVjdCBkZXZpY2UgKmRldikKK3N0YXRpYyBzdHJ1Y3QgZ2VuZXJpY19wbV9kb21haW5fZGF0YSAqZ2VucGRfYWxsb2NfZGV2X2RhdGEoc3RydWN0IGRldmljZSAqZGV2LAorCQkJCQlzdHJ1Y3QgZ2VuZXJpY19wbV9kb21haW4gKmdlbnBkLAorCQkJCQlzdHJ1Y3QgZ3BkX3RpbWluZ19kYXRhICp0ZCkKIHsKIAlzdHJ1Y3QgZ2VuZXJpY19wbV9kb21haW5fZGF0YSAqZ3BkX2RhdGE7CisJaW50IHJldDsKKworCXJldCA9IGRldl9wbV9nZXRfc3Vic3lzX2RhdGEoZGV2KTsKKwlpZiAocmV0KQorCQlyZXR1cm4gRVJSX1BUUihyZXQpOwogCiAJZ3BkX2RhdGEgPSBremFsbG9jKHNpemVvZigqZ3BkX2RhdGEpLCBHRlBfS0VSTkVMKTsKLQlpZiAoIWdwZF9kYXRhKQotCQlyZXR1cm4gTlVMTDsKKwlpZiAoIWdwZF9kYXRhKSB7CisJCXJldCA9IC1FTk9NRU07CisJCWdvdG8gZXJyX3B1dDsKKwl9CiAKLQltdXRleF9pbml0KCZncGRfZGF0YS0+bG9jayk7CisJaWYgKHRkKQorCQlncGRfZGF0YS0+dGQgPSAqdGQ7CisKKwlncGRfZGF0YS0+YmFzZS5kZXYgPSBkZXY7CisJZ3BkX2RhdGEtPm5lZWRfcmVzdG9yZSA9IC0xOworCWdwZF9kYXRhLT50ZC5jb25zdHJhaW50X2NoYW5nZWQgPSB0cnVlOworCWdwZF9kYXRhLT50ZC5lZmZlY3RpdmVfY29uc3RyYWludF9ucyA9IC0xOwogCWdwZF9kYXRhLT5uYi5ub3RpZmllcl9jYWxsID0gZ2VucGRfZGV2X3BtX3Fvc19ub3RpZmllcjsKLQlkZXZfcG1fcW9zX2FkZF9ub3RpZmllcihkZXYsICZncGRfZGF0YS0+bmIpOworCisJc3Bpbl9sb2NrX2lycSgmZGV2LT5wb3dlci5sb2NrKTsKKworCWlmIChkZXYtPnBvd2VyLnN1YnN5c19kYXRhLT5kb21haW5fZGF0YSkgeworCQlyZXQgPSAtRUlOVkFMOworCQlnb3RvIGVycl9mcmVlOworCX0KKworCWRldi0+cG93ZXIuc3Vic3lzX2RhdGEtPmRvbWFpbl9kYXRhID0gJmdwZF9kYXRhLT5iYXNlOworCWRldi0+cG1fZG9tYWluID0gJmdlbnBkLT5kb21haW47CisKKwlzcGluX3VubG9ja19pcnEoJmRldi0+cG93ZXIubG9jayk7CisKIAlyZXR1cm4gZ3BkX2RhdGE7CisKKyBlcnJfZnJlZToKKwlzcGluX3VubG9ja19pcnEoJmRldi0+cG93ZXIubG9jayk7CisJa2ZyZWUoZ3BkX2RhdGEpOworIGVycl9wdXQ6CisJZGV2X3BtX3B1dF9zdWJzeXNfZGF0YShkZXYpOworCXJldHVybiBFUlJfUFRSKHJldCk7CiB9CiAKLXN0YXRpYyB2b2lkIF9fcG1fZ2VucGRfZnJlZV9kZXZfZGF0YShzdHJ1Y3QgZGV2aWNlICpkZXYsCi0JCQkJICAgICBzdHJ1Y3QgZ2VuZXJpY19wbV9kb21haW5fZGF0YSAqZ3BkX2RhdGEpCitzdGF0aWMgdm9pZCBnZW5wZF9mcmVlX2Rldl9kYXRhKHN0cnVjdCBkZXZpY2UgKmRldiwKKwkJCQlzdHJ1Y3QgZ2VuZXJpY19wbV9kb21haW5fZGF0YSAqZ3BkX2RhdGEpCiB7Ci0JZGV2X3BtX3Fvc19yZW1vdmVfbm90aWZpZXIoZGV2LCAmZ3BkX2RhdGEtPm5iKTsKKwlzcGluX2xvY2tfaXJxKCZkZXYtPnBvd2VyLmxvY2spOworCisJZGV2LT5wbV9kb21haW4gPSBOVUxMOworCWRldi0+cG93ZXIuc3Vic3lzX2RhdGEtPmRvbWFpbl9kYXRhID0gTlVMTDsKKworCXNwaW5fdW5sb2NrX2lycSgmZGV2LT5wb3dlci5sb2NrKTsKKwogCWtmcmVlKGdwZF9kYXRhKTsKKwlkZXZfcG1fcHV0X3N1YnN5c19kYXRhKGRldik7CiB9CiAKIC8qKgpAQCAtMTQxNCw4ICsxNDQ4LDcgQEAKIGludCBfX3BtX2dlbnBkX2FkZF9kZXZpY2Uoc3RydWN0IGdlbmVyaWNfcG1fZG9tYWluICpnZW5wZCwgc3RydWN0IGRldmljZSAqZGV2LAogCQkJICBzdHJ1Y3QgZ3BkX3RpbWluZ19kYXRhICp0ZCkKIHsKLQlzdHJ1Y3QgZ2VuZXJpY19wbV9kb21haW5fZGF0YSAqZ3BkX2RhdGFfbmV3LCAqZ3BkX2RhdGEgPSBOVUxMOwotCXN0cnVjdCBwbV9kb21haW5fZGF0YSAqcGRkOworCXN0cnVjdCBnZW5lcmljX3BtX2RvbWFpbl9kYXRhICpncGRfZGF0YTsKIAlpbnQgcmV0ID0gMDsKIAogCWRldl9kYmcoZGV2LCAiJXMoKVxuIiwgX19mdW5jX18pOwpAQCAtMTQyMyw5ICsxNDU2LDkgQEAKIAlpZiAoSVNfRVJSX09SX05VTEwoZ2VucGQpIHx8IElTX0VSUl9PUl9OVUxMKGRldikpCiAJCXJldHVybiAtRUlOVkFMOwogCi0JZ3BkX2RhdGFfbmV3ID0gX19wbV9nZW5wZF9hbGxvY19kZXZfZGF0YShkZXYpOwotCWlmICghZ3BkX2RhdGFfbmV3KQotCQlyZXR1cm4gLUVOT01FTTsKKwlncGRfZGF0YSA9IGdlbnBkX2FsbG9jX2Rldl9kYXRhKGRldiwgZ2VucGQsIHRkKTsKKwlpZiAoSVNfRVJSKGdwZF9kYXRhKSkKKwkJcmV0dXJuIFBUUl9FUlIoZ3BkX2RhdGEpOwogCiAJZ2VucGRfYWNxdWlyZV9sb2NrKGdlbnBkKTsKIApAQCAtMTQzNCw1MCArMTQ2NywyMiBAQAogCQlnb3RvIG91dDsKIAl9CiAKLQlsaXN0X2Zvcl9lYWNoX2VudHJ5KHBkZCwgJmdlbnBkLT5kZXZfbGlzdCwgbGlzdF9ub2RlKQotCQlpZiAocGRkLT5kZXYgPT0gZGV2KSB7Ci0JCQlyZXQgPSAtRUlOVkFMOwotCQkJZ290byBvdXQ7Ci0JCX0KLQotCXJldCA9IGRldl9wbV9nZXRfc3Vic3lzX2RhdGEoZGV2KTsKKwlyZXQgPSBnZW5wZC0+YXR0YWNoX2RldiA/IGdlbnBkLT5hdHRhY2hfZGV2KGdlbnBkLCBkZXYpIDogMDsKIAlpZiAocmV0KQogCQlnb3RvIG91dDsKIAogCWdlbnBkLT5kZXZpY2VfY291bnQrKzsKIAlnZW5wZC0+bWF4X29mZl90aW1lX2NoYW5nZWQgPSB0cnVlOwogCi0Jc3Bpbl9sb2NrX2lycSgmZGV2LT5wb3dlci5sb2NrKTsKLQotCWRldi0+cG1fZG9tYWluID0gJmdlbnBkLT5kb21haW47Ci0JaWYgKGRldi0+cG93ZXIuc3Vic3lzX2RhdGEtPmRvbWFpbl9kYXRhKSB7Ci0JCWdwZF9kYXRhID0gdG9fZ3BkX2RhdGEoZGV2LT5wb3dlci5zdWJzeXNfZGF0YS0+ZG9tYWluX2RhdGEpOwotCX0gZWxzZSB7Ci0JCWdwZF9kYXRhID0gZ3BkX2RhdGFfbmV3OwotCQlkZXYtPnBvd2VyLnN1YnN5c19kYXRhLT5kb21haW5fZGF0YSA9ICZncGRfZGF0YS0+YmFzZTsKLQl9Ci0JZ3BkX2RhdGEtPnJlZmNvdW50Kys7Ci0JaWYgKHRkKQotCQlncGRfZGF0YS0+dGQgPSAqdGQ7Ci0KLQlzcGluX3VubG9ja19pcnEoJmRldi0+cG93ZXIubG9jayk7Ci0KLQlpZiAoZ2VucGQtPmF0dGFjaF9kZXYpCi0JCWdlbnBkLT5hdHRhY2hfZGV2KGdlbnBkLCBkZXYpOwotCi0JbXV0ZXhfbG9jaygmZ3BkX2RhdGEtPmxvY2spOwotCWdwZF9kYXRhLT5iYXNlLmRldiA9IGRldjsKIAlsaXN0X2FkZF90YWlsKCZncGRfZGF0YS0+YmFzZS5saXN0X25vZGUsICZnZW5wZC0+ZGV2X2xpc3QpOwotCWdwZF9kYXRhLT5uZWVkX3Jlc3RvcmUgPSAtMTsKLQlncGRfZGF0YS0+dGQuY29uc3RyYWludF9jaGFuZ2VkID0gdHJ1ZTsKLQlncGRfZGF0YS0+dGQuZWZmZWN0aXZlX2NvbnN0cmFpbnRfbnMgPSAtMTsKLQltdXRleF91bmxvY2soJmdwZF9kYXRhLT5sb2NrKTsKIAogIG91dDoKIAlnZW5wZF9yZWxlYXNlX2xvY2soZ2VucGQpOwogCi0JaWYgKGdwZF9kYXRhICE9IGdwZF9kYXRhX25ldykKLQkJX19wbV9nZW5wZF9mcmVlX2Rldl9kYXRhKGRldiwgZ3BkX2RhdGFfbmV3KTsKKwlpZiAocmV0KQorCQlnZW5wZF9mcmVlX2Rldl9kYXRhKGRldiwgZ3BkX2RhdGEpOworCWVsc2UKKwkJZGV2X3BtX3Fvc19hZGRfbm90aWZpZXIoZGV2LCAmZ3BkX2RhdGEtPm5iKTsKIAogCXJldHVybiByZXQ7CiB9CkBAIC0xNTA0LDcgKzE1MDksNiBAQAogewogCXN0cnVjdCBnZW5lcmljX3BtX2RvbWFpbl9kYXRhICpncGRfZGF0YTsKIAlzdHJ1Y3QgcG1fZG9tYWluX2RhdGEgKnBkZDsKLQlib29sIHJlbW92ZSA9IGZhbHNlOwogCWludCByZXQgPSAwOwogCiAJZGV2X2RiZyhkZXYsICIlcygpXG4iLCBfX2Z1bmNfXyk7CkBAIC0xNTE0LDYgKzE1MTgsMTEgQEAKIAkgICAgfHwgIHBkX3RvX2dlbnBkKGRldi0+cG1fZG9tYWluKSAhPSBnZW5wZCkKIAkJcmV0dXJuIC1FSU5WQUw7CiAKKwkvKiBUaGUgYWJvdmUgdmFsaWRhdGlvbiBhbHNvIG1lYW5zIHdlIGhhdmUgZXhpc3RpbmcgZG9tYWluX2RhdGEuICovCisJcGRkID0gZGV2LT5wb3dlci5zdWJzeXNfZGF0YS0+ZG9tYWluX2RhdGE7CisJZ3BkX2RhdGEgPSB0b19ncGRfZGF0YShwZGQpOworCWRldl9wbV9xb3NfcmVtb3ZlX25vdGlmaWVyKGRldiwgJmdwZF9kYXRhLT5uYik7CisKIAlnZW5wZF9hY3F1aXJlX2xvY2soZ2VucGQpOwogCiAJaWYgKGdlbnBkLT5wcmVwYXJlZF9jb3VudCA+IDApIHsKQEAgLTE1MjcsNTggKzE1MzYsMjIgQEAKIAlpZiAoZ2VucGQtPmRldGFjaF9kZXYpCiAJCWdlbnBkLT5kZXRhY2hfZGV2KGdlbnBkLCBkZXYpOwogCi0Jc3Bpbl9sb2NrX2lycSgmZGV2LT5wb3dlci5sb2NrKTsKLQotCWRldi0+cG1fZG9tYWluID0gTlVMTDsKLQlwZGQgPSBkZXYtPnBvd2VyLnN1YnN5c19kYXRhLT5kb21haW5fZGF0YTsKIAlsaXN0X2RlbF9pbml0KCZwZGQtPmxpc3Rfbm9kZSk7Ci0JZ3BkX2RhdGEgPSB0b19ncGRfZGF0YShwZGQpOwotCWlmICgtLWdwZF9kYXRhLT5yZWZjb3VudCA9PSAwKSB7Ci0JCWRldi0+cG93ZXIuc3Vic3lzX2RhdGEtPmRvbWFpbl9kYXRhID0gTlVMTDsKLQkJcmVtb3ZlID0gdHJ1ZTsKLQl9Ci0KLQlzcGluX3VubG9ja19pcnEoJmRldi0+cG93ZXIubG9jayk7Ci0KLQltdXRleF9sb2NrKCZncGRfZGF0YS0+bG9jayk7Ci0JcGRkLT5kZXYgPSBOVUxMOwotCW11dGV4X3VubG9jaygmZ3BkX2RhdGEtPmxvY2spOwogCiAJZ2VucGRfcmVsZWFzZV9sb2NrKGdlbnBkKTsKIAotCWRldl9wbV9wdXRfc3Vic3lzX2RhdGEoZGV2KTsKLQlpZiAocmVtb3ZlKQotCQlfX3BtX2dlbnBkX2ZyZWVfZGV2X2RhdGEoZGV2LCBncGRfZGF0YSk7CisJZ2VucGRfZnJlZV9kZXZfZGF0YShkZXYsIGdwZF9kYXRhKTsKIAogCXJldHVybiAwOwogCiAgb3V0OgogCWdlbnBkX3JlbGVhc2VfbG9jayhnZW5wZCk7CisJZGV2X3BtX3Fvc19hZGRfbm90aWZpZXIoZGV2LCAmZ3BkX2RhdGEtPm5iKTsKIAogCXJldHVybiByZXQ7CiB9CiAKIC8qKgotICogcG1fZ2VucGRfZGV2X25lZWRfcmVzdG9yZSAtIFNldC91bnNldCB0aGUgZGV2aWNlJ3MgIm5lZWQgcmVzdG9yZSIgZmxhZy4KLSAqIEBkZXY6IERldmljZSB0byBzZXQvdW5zZXQgdGhlIGZsYWcgZm9yLgotICogQHZhbDogVGhlIG5ldyB2YWx1ZSBvZiB0aGUgZGV2aWNlJ3MgIm5lZWQgcmVzdG9yZSIgZmxhZy4KLSAqLwotdm9pZCBwbV9nZW5wZF9kZXZfbmVlZF9yZXN0b3JlKHN0cnVjdCBkZXZpY2UgKmRldiwgYm9vbCB2YWwpCi17Ci0Jc3RydWN0IHBtX3N1YnN5c19kYXRhICpwc2Q7Ci0JdW5zaWduZWQgbG9uZyBmbGFnczsKLQotCXNwaW5fbG9ja19pcnFzYXZlKCZkZXYtPnBvd2VyLmxvY2ssIGZsYWdzKTsKLQotCXBzZCA9IGRldl90b19wc2QoZGV2KTsKLQlpZiAocHNkICYmIHBzZC0+ZG9tYWluX2RhdGEpCi0JCXRvX2dwZF9kYXRhKHBzZC0+ZG9tYWluX2RhdGEpLT5uZWVkX3Jlc3RvcmUgPSB2YWwgPyAxIDogMDsKLQotCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmRldi0+cG93ZXIubG9jaywgZmxhZ3MpOwotfQotRVhQT1JUX1NZTUJPTF9HUEwocG1fZ2VucGRfZGV2X25lZWRfcmVzdG9yZSk7Ci0KLS8qKgogICogcG1fZ2VucGRfYWRkX3N1YmRvbWFpbiAtIEFkZCBhIHN1YmRvbWFpbiB0byBhbiBJL08gUE0gZG9tYWluLgogICogQGdlbnBkOiBNYXN0ZXIgUE0gZG9tYWluIHRvIGFkZCB0aGUgc3ViZG9tYWluIHRvLgogICogQHN1YmRvbWFpbjogU3ViZG9tYWluIHRvIGJlIGFkZGVkLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9iYXNlL3Bvd2VyL29wcC5jIGIvZHJpdmVycy9iYXNlL3Bvd2VyL29wcC5jCmluZGV4IDEwNmM2OTMuLjE1YmYyOTkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYmFzZS9wb3dlci9vcHAuYworKysgYi9kcml2ZXJzL2Jhc2UvcG93ZXIvb3BwLmMKQEAgLTExNywyMCArMTE3LDIwIEBACiB9IHdoaWxlICgwKQogCiAvKioKLSAqIGZpbmRfZGV2aWNlX29wcCgpIC0gZmluZCBkZXZpY2Vfb3BwIHN0cnVjdCB1c2luZyBkZXZpY2UgcG9pbnRlcgorICogX2ZpbmRfZGV2aWNlX29wcCgpIC0gZmluZCBkZXZpY2Vfb3BwIHN0cnVjdCB1c2luZyBkZXZpY2UgcG9pbnRlcgogICogQGRldjoJZGV2aWNlIHBvaW50ZXIgdXNlZCB0byBsb29rdXAgZGV2aWNlIE9QUHMKICAqCiAgKiBTZWFyY2ggbGlzdCBvZiBkZXZpY2UgT1BQcyBmb3Igb25lIGNvbnRhaW5pbmcgbWF0Y2hpbmcgZGV2aWNlLiBEb2VzIGEgUkNVCiAgKiByZWFkZXIgb3BlcmF0aW9uIHRvIGdyYWIgdGhlIHBvaW50ZXIgbmVlZGVkLgogICoKLSAqIFJldHVybnMgcG9pbnRlciB0byAnc3RydWN0IGRldmljZV9vcHAnIGlmIGZvdW5kLCBvdGhlcndpc2UgLUVOT0RFViBvcgorICogUmV0dXJuOiBwb2ludGVyIHRvICdzdHJ1Y3QgZGV2aWNlX29wcCcgaWYgZm91bmQsIG90aGVyd2lzZSAtRU5PREVWIG9yCiAgKiAtRUlOVkFMIGJhc2VkIG9uIHR5cGUgb2YgZXJyb3IuCiAgKgogICogTG9ja2luZzogVGhpcyBmdW5jdGlvbiBtdXN0IGJlIGNhbGxlZCB1bmRlciByY3VfcmVhZF9sb2NrKCkuIGRldmljZV9vcHAKICAqIGlzIGEgUkNVIHByb3RlY3RlZCBwb2ludGVyLiBUaGlzIG1lYW5zIHRoYXQgZGV2aWNlX29wcCBpcyB2YWxpZCBhcyBsb25nCiAgKiBhcyB3ZSBhcmUgdW5kZXIgUkNVIGxvY2suCiAgKi8KLXN0YXRpYyBzdHJ1Y3QgZGV2aWNlX29wcCAqZmluZF9kZXZpY2Vfb3BwKHN0cnVjdCBkZXZpY2UgKmRldikKK3N0YXRpYyBzdHJ1Y3QgZGV2aWNlX29wcCAqX2ZpbmRfZGV2aWNlX29wcChzdHJ1Y3QgZGV2aWNlICpkZXYpCiB7CiAJc3RydWN0IGRldmljZV9vcHAgKnRtcF9kZXZfb3BwLCAqZGV2X29wcCA9IEVSUl9QVFIoLUVOT0RFVik7CiAKQEAgLTE1Myw3ICsxNTMsNyBAQAogICogZGV2X3BtX29wcF9nZXRfdm9sdGFnZSgpIC0gR2V0cyB0aGUgdm9sdGFnZSBjb3JyZXNwb25kaW5nIHRvIGFuIGF2YWlsYWJsZSBvcHAKICAqIEBvcHA6CW9wcCBmb3Igd2hpY2ggdm9sdGFnZSBoYXMgdG8gYmUgcmV0dXJuZWQgZm9yCiAgKgotICogUmV0dXJuIHZvbHRhZ2UgaW4gbWljcm8gdm9sdCBjb3JyZXNwb25kaW5nIHRvIHRoZSBvcHAsIGVsc2UKKyAqIFJldHVybjogdm9sdGFnZSBpbiBtaWNybyB2b2x0IGNvcnJlc3BvbmRpbmcgdG8gdGhlIG9wcCwgZWxzZQogICogcmV0dXJuIDAKICAqCiAgKiBMb2NraW5nOiBUaGlzIGZ1bmN0aW9uIG11c3QgYmUgY2FsbGVkIHVuZGVyIHJjdV9yZWFkX2xvY2soKS4gb3BwIGlzIGEgcmN1CkBAIC0xNjksNiArMTY5LDggQEAKIAlzdHJ1Y3QgZGV2X3BtX29wcCAqdG1wX29wcDsKIAl1bnNpZ25lZCBsb25nIHYgPSAwOwogCisJb3BwX3JjdV9sb2NrZGVwX2Fzc2VydCgpOworCiAJdG1wX29wcCA9IHJjdV9kZXJlZmVyZW5jZShvcHApOwogCWlmICh1bmxpa2VseShJU19FUlJfT1JfTlVMTCh0bXBfb3BwKSkgfHwgIXRtcF9vcHAtPmF2YWlsYWJsZSkKIAkJcHJfZXJyKCIlczogSW52YWxpZCBwYXJhbWV0ZXJzXG4iLCBfX2Z1bmNfXyk7CkBAIC0xODMsNyArMTg1LDcgQEAKICAqIGRldl9wbV9vcHBfZ2V0X2ZyZXEoKSAtIEdldHMgdGhlIGZyZXF1ZW5jeSBjb3JyZXNwb25kaW5nIHRvIGFuIGF2YWlsYWJsZSBvcHAKICAqIEBvcHA6CW9wcCBmb3Igd2hpY2ggZnJlcXVlbmN5IGhhcyB0byBiZSByZXR1cm5lZCBmb3IKICAqCi0gKiBSZXR1cm4gZnJlcXVlbmN5IGluIGhlcnR6IGNvcnJlc3BvbmRpbmcgdG8gdGhlIG9wcCwgZWxzZQorICogUmV0dXJuOiBmcmVxdWVuY3kgaW4gaGVydHogY29ycmVzcG9uZGluZyB0byB0aGUgb3BwLCBlbHNlCiAgKiByZXR1cm4gMAogICoKICAqIExvY2tpbmc6IFRoaXMgZnVuY3Rpb24gbXVzdCBiZSBjYWxsZWQgdW5kZXIgcmN1X3JlYWRfbG9jaygpLiBvcHAgaXMgYSByY3UKQEAgLTE5OSw2ICsyMDEsOCBAQAogCXN0cnVjdCBkZXZfcG1fb3BwICp0bXBfb3BwOwogCXVuc2lnbmVkIGxvbmcgZiA9IDA7CiAKKwlvcHBfcmN1X2xvY2tkZXBfYXNzZXJ0KCk7CisKIAl0bXBfb3BwID0gcmN1X2RlcmVmZXJlbmNlKG9wcCk7CiAJaWYgKHVubGlrZWx5KElTX0VSUl9PUl9OVUxMKHRtcF9vcHApKSB8fCAhdG1wX29wcC0+YXZhaWxhYmxlKQogCQlwcl9lcnIoIiVzOiBJbnZhbGlkIHBhcmFtZXRlcnNcbiIsIF9fZnVuY19fKTsKQEAgLTIxMyw3ICsyMTcsNyBAQAogICogZGV2X3BtX29wcF9nZXRfb3BwX2NvdW50KCkgLSBHZXQgbnVtYmVyIG9mIG9wcHMgYXZhaWxhYmxlIGluIHRoZSBvcHAgbGlzdAogICogQGRldjoJZGV2aWNlIGZvciB3aGljaCB3ZSBkbyB0aGlzIG9wZXJhdGlvbgogICoKLSAqIFRoaXMgZnVuY3Rpb24gcmV0dXJucyB0aGUgbnVtYmVyIG9mIGF2YWlsYWJsZSBvcHBzIGlmIHRoZXJlIGFyZSBhbnksCisgKiBSZXR1cm46IFRoaXMgZnVuY3Rpb24gcmV0dXJucyB0aGUgbnVtYmVyIG9mIGF2YWlsYWJsZSBvcHBzIGlmIHRoZXJlIGFyZSBhbnksCiAgKiBlbHNlIHJldHVybnMgMCBpZiBub25lIG9yIHRoZSBjb3JyZXNwb25kaW5nIGVycm9yIHZhbHVlLgogICoKICAqIExvY2tpbmc6IFRoaXMgZnVuY3Rpb24gdGFrZXMgcmN1X3JlYWRfbG9jaygpLgpAQCAtMjI2LDcgKzIzMCw3IEBACiAKIAlyY3VfcmVhZF9sb2NrKCk7CiAKLQlkZXZfb3BwID0gZmluZF9kZXZpY2Vfb3BwKGRldik7CisJZGV2X29wcCA9IF9maW5kX2RldmljZV9vcHAoZGV2KTsKIAlpZiAoSVNfRVJSKGRldl9vcHApKSB7CiAJCWNvdW50ID0gUFRSX0VSUihkZXZfb3BwKTsKIAkJZGV2X2VycihkZXYsICIlczogZGV2aWNlIE9QUCBub3QgZm91bmQgKCVkKVxuIiwKQEAgLTI1MSw5ICsyNTUsOSBAQAogICogQGZyZXE6CQlmcmVxdWVuY3kgdG8gc2VhcmNoIGZvcgogICogQGF2YWlsYWJsZToJCXRydWUvZmFsc2UgLSBtYXRjaCBmb3IgYXZhaWxhYmxlIG9wcAogICoKLSAqIFNlYXJjaGVzIGZvciBleGFjdCBtYXRjaCBpbiB0aGUgb3BwIGxpc3QgYW5kIHJldHVybnMgcG9pbnRlciB0byB0aGUgbWF0Y2hpbmcKLSAqIG9wcCBpZiBmb3VuZCwgZWxzZSByZXR1cm5zIEVSUl9QVFIgaW4gY2FzZSBvZiBlcnJvciBhbmQgc2hvdWxkIGJlIGhhbmRsZWQKLSAqIHVzaW5nIElTX0VSUi4gRXJyb3IgcmV0dXJuIHZhbHVlcyBjYW4gYmU6CisgKiBSZXR1cm46IFNlYXJjaGVzIGZvciBleGFjdCBtYXRjaCBpbiB0aGUgb3BwIGxpc3QgYW5kIHJldHVybnMgcG9pbnRlciB0byB0aGUKKyAqIG1hdGNoaW5nIG9wcCBpZiBmb3VuZCwgZWxzZSByZXR1cm5zIEVSUl9QVFIgaW4gY2FzZSBvZiBlcnJvciBhbmQgc2hvdWxkCisgKiBiZSBoYW5kbGVkIHVzaW5nIElTX0VSUi4gRXJyb3IgcmV0dXJuIHZhbHVlcyBjYW4gYmU6CiAgKiBFSU5WQUw6CWZvciBiYWQgcG9pbnRlcgogICogRVJBTkdFOglubyBtYXRjaCBmb3VuZCBmb3Igc2VhcmNoCiAgKiBFTk9ERVY6CWlmIGRldmljZSBub3QgZm91bmQgaW4gbGlzdCBvZiByZWdpc3RlcmVkIGRldmljZXMKQEAgLTI4MCw3ICsyODQsNyBAQAogCiAJb3BwX3JjdV9sb2NrZGVwX2Fzc2VydCgpOwogCi0JZGV2X29wcCA9IGZpbmRfZGV2aWNlX29wcChkZXYpOworCWRldl9vcHAgPSBfZmluZF9kZXZpY2Vfb3BwKGRldik7CiAJaWYgKElTX0VSUihkZXZfb3BwKSkgewogCQlpbnQgciA9IFBUUl9FUlIoZGV2X29wcCk7CiAJCWRldl9lcnIoZGV2LCAiJXM6IGRldmljZSBPUFAgbm90IGZvdW5kICglZClcbiIsIF9fZnVuY19fLCByKTsKQEAgLTMwNyw3ICszMTEsNyBAQAogICogU2VhcmNoIGZvciB0aGUgbWF0Y2hpbmcgY2VpbCAqYXZhaWxhYmxlKiBPUFAgZnJvbSBhIHN0YXJ0aW5nIGZyZXEKICAqIGZvciBhIGRldmljZS4KICAqCi0gKiBSZXR1cm5zIG1hdGNoaW5nICpvcHAgYW5kIHJlZnJlc2hlcyAqZnJlcSBhY2NvcmRpbmdseSwgZWxzZSByZXR1cm5zCisgKiBSZXR1cm46IG1hdGNoaW5nICpvcHAgYW5kIHJlZnJlc2hlcyAqZnJlcSBhY2NvcmRpbmdseSwgZWxzZSByZXR1cm5zCiAgKiBFUlJfUFRSIGluIGNhc2Ugb2YgZXJyb3IgYW5kIHNob3VsZCBiZSBoYW5kbGVkIHVzaW5nIElTX0VSUi4gRXJyb3IgcmV0dXJuCiAgKiB2YWx1ZXMgY2FuIGJlOgogICogRUlOVkFMOglmb3IgYmFkIHBvaW50ZXIKQEAgLTMzMyw3ICszMzcsNyBAQAogCQlyZXR1cm4gRVJSX1BUUigtRUlOVkFMKTsKIAl9CiAKLQlkZXZfb3BwID0gZmluZF9kZXZpY2Vfb3BwKGRldik7CisJZGV2X29wcCA9IF9maW5kX2RldmljZV9vcHAoZGV2KTsKIAlpZiAoSVNfRVJSKGRldl9vcHApKQogCQlyZXR1cm4gRVJSX0NBU1QoZGV2X29wcCk7CiAKQEAgLTM1Nyw3ICszNjEsNyBAQAogICogU2VhcmNoIGZvciB0aGUgbWF0Y2hpbmcgZmxvb3IgKmF2YWlsYWJsZSogT1BQIGZyb20gYSBzdGFydGluZyBmcmVxCiAgKiBmb3IgYSBkZXZpY2UuCiAgKgotICogUmV0dXJucyBtYXRjaGluZyAqb3BwIGFuZCByZWZyZXNoZXMgKmZyZXEgYWNjb3JkaW5nbHksIGVsc2UgcmV0dXJucworICogUmV0dXJuOiBtYXRjaGluZyAqb3BwIGFuZCByZWZyZXNoZXMgKmZyZXEgYWNjb3JkaW5nbHksIGVsc2UgcmV0dXJucwogICogRVJSX1BUUiBpbiBjYXNlIG9mIGVycm9yIGFuZCBzaG91bGQgYmUgaGFuZGxlZCB1c2luZyBJU19FUlIuIEVycm9yIHJldHVybgogICogdmFsdWVzIGNhbiBiZToKICAqIEVJTlZBTDoJZm9yIGJhZCBwb2ludGVyCkBAIC0zODMsNyArMzg3LDcgQEAKIAkJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7CiAJfQogCi0JZGV2X29wcCA9IGZpbmRfZGV2aWNlX29wcChkZXYpOworCWRldl9vcHAgPSBfZmluZF9kZXZpY2Vfb3BwKGRldik7CiAJaWYgKElTX0VSUihkZXZfb3BwKSkKIAkJcmV0dXJuIEVSUl9DQVNUKGRldl9vcHApOwogCkBAIC00MDMsNyArNDA3LDE2IEBACiB9CiBFWFBPUlRfU1lNQk9MX0dQTChkZXZfcG1fb3BwX2ZpbmRfZnJlcV9mbG9vcik7CiAKLXN0YXRpYyBzdHJ1Y3QgZGV2aWNlX29wcCAqYWRkX2RldmljZV9vcHAoc3RydWN0IGRldmljZSAqZGV2KQorLyoqCisgKiBfYWRkX2RldmljZV9vcHAoKSAtIEFsbG9jYXRlIGEgbmV3IGRldmljZSBPUFAgdGFibGUKKyAqIEBkZXY6CWRldmljZSBmb3Igd2hpY2ggd2UgZG8gdGhpcyBvcGVyYXRpb24KKyAqCisgKiBOZXcgZGV2aWNlIG5vZGUgd2hpY2ggdXNlcyBPUFBzIC0gdXNlZCB3aGVuIG11bHRpcGxlIGRldmljZXMgd2l0aCBPUFAgdGFibGVzCisgKiBhcmUgbWFpbnRhaW5lZC4KKyAqCisgKiBSZXR1cm46IHZhbGlkIGRldmljZV9vcHAgcG9pbnRlciBpZiBzdWNjZXNzLCBlbHNlIE5VTEwuCisgKi8KK3N0YXRpYyBzdHJ1Y3QgZGV2aWNlX29wcCAqX2FkZF9kZXZpY2Vfb3BwKHN0cnVjdCBkZXZpY2UgKmRldikKIHsKIAlzdHJ1Y3QgZGV2aWNlX29wcCAqZGV2X29wcDsKIApAQCAtNDI0LDggKzQzNywzNSBAQAogCXJldHVybiBkZXZfb3BwOwogfQogCi1zdGF0aWMgaW50IGRldl9wbV9vcHBfYWRkX2R5bmFtaWMoc3RydWN0IGRldmljZSAqZGV2LCB1bnNpZ25lZCBsb25nIGZyZXEsCi0JCQkJICB1bnNpZ25lZCBsb25nIHVfdm9sdCwgYm9vbCBkeW5hbWljKQorLyoqCisgKiBfb3BwX2FkZF9keW5hbWljKCkgLSBBbGxvY2F0ZSBhIGR5bmFtaWMgT1BQLgorICogQGRldjoJZGV2aWNlIGZvciB3aGljaCB3ZSBkbyB0aGlzIG9wZXJhdGlvbgorICogQGZyZXE6CUZyZXF1ZW5jeSBpbiBIeiBmb3IgdGhpcyBPUFAKKyAqIEB1X3ZvbHQ6CVZvbHRhZ2UgaW4gdVZvbHRzIGZvciB0aGlzIE9QUAorICogQGR5bmFtaWM6CUR5bmFtaWNhbGx5IGFkZGVkIE9QUHMuCisgKgorICogVGhpcyBmdW5jdGlvbiBhZGRzIGFuIG9wcCBkZWZpbml0aW9uIHRvIHRoZSBvcHAgbGlzdCBhbmQgcmV0dXJucyBzdGF0dXMuCisgKiBUaGUgb3BwIGlzIG1hZGUgYXZhaWxhYmxlIGJ5IGRlZmF1bHQgYW5kIGl0IGNhbiBiZSBjb250cm9sbGVkIHVzaW5nCisgKiBkZXZfcG1fb3BwX2VuYWJsZS9kaXNhYmxlIGZ1bmN0aW9ucyBhbmQgbWF5IGJlIHJlbW92ZWQgYnkgZGV2X3BtX29wcF9yZW1vdmUuCisgKgorICogTk9URTogImR5bmFtaWMiIHBhcmFtZXRlciBpbXBhY3RzIE9QUHMgYWRkZWQgYnkgdGhlIG9mX2luaXRfb3BwX3RhYmxlIGFuZAorICogZnJlZWQgYnkgb2ZfZnJlZV9vcHBfdGFibGUuCisgKgorICogTG9ja2luZzogVGhlIGludGVybmFsIGRldmljZV9vcHAgYW5kIG9wcCBzdHJ1Y3R1cmVzIGFyZSBSQ1UgcHJvdGVjdGVkLgorICogSGVuY2UgdGhpcyBmdW5jdGlvbiBpbnRlcm5hbGx5IHVzZXMgUkNVIHVwZGF0ZXIgc3RyYXRlZ3kgd2l0aCBtdXRleCBsb2NrcworICogdG8ga2VlcCB0aGUgaW50ZWdyaXR5IG9mIHRoZSBpbnRlcm5hbCBkYXRhIHN0cnVjdHVyZXMuIENhbGxlcnMgc2hvdWxkIGVuc3VyZQorICogdGhhdCB0aGlzIGZ1bmN0aW9uIGlzICpOT1QqIGNhbGxlZCB1bmRlciBSQ1UgcHJvdGVjdGlvbiBvciBpbiBjb250ZXh0cyB3aGVyZQorICogbXV0ZXggY2Fubm90IGJlIGxvY2tlZC4KKyAqCisgKiBSZXR1cm46CisgKiAwCQlPbiBzdWNjZXNzIE9SCisgKgkJRHVwbGljYXRlIE9QUHMgKGJvdGggZnJlcSBhbmQgdm9sdCBhcmUgc2FtZSkgYW5kIG9wcC0+YXZhaWxhYmxlCisgKiAtRUVYSVNUCUZyZXEgYXJlIHNhbWUgYW5kIHZvbHQgYXJlIGRpZmZlcmVudCBPUgorICoJCUR1cGxpY2F0ZSBPUFBzIChib3RoIGZyZXEgYW5kIHZvbHQgYXJlIHNhbWUpIGFuZCAhb3BwLT5hdmFpbGFibGUKKyAqIC1FTk9NRU0JTWVtb3J5IGFsbG9jYXRpb24gZmFpbHVyZQorICovCitzdGF0aWMgaW50IF9vcHBfYWRkX2R5bmFtaWMoc3RydWN0IGRldmljZSAqZGV2LCB1bnNpZ25lZCBsb25nIGZyZXEsCisJCQkgICAgbG9uZyB1X3ZvbHQsIGJvb2wgZHluYW1pYykKIHsKIAlzdHJ1Y3QgZGV2aWNlX29wcCAqZGV2X29wcCA9IE5VTEw7CiAJc3RydWN0IGRldl9wbV9vcHAgKm9wcCwgKm5ld19vcHA7CkBAIC00NDksOSArNDg5LDkgQEAKIAluZXdfb3BwLT5keW5hbWljID0gZHluYW1pYzsKIAogCS8qIENoZWNrIGZvciBleGlzdGluZyBsaXN0IGZvciAnZGV2JyAqLwotCWRldl9vcHAgPSBmaW5kX2RldmljZV9vcHAoZGV2KTsKKwlkZXZfb3BwID0gX2ZpbmRfZGV2aWNlX29wcChkZXYpOwogCWlmIChJU19FUlIoZGV2X29wcCkpIHsKLQkJZGV2X29wcCA9IGFkZF9kZXZpY2Vfb3BwKGRldik7CisJCWRldl9vcHAgPSBfYWRkX2RldmljZV9vcHAoZGV2KTsKIAkJaWYgKCFkZXZfb3BwKSB7CiAJCQlyZXQgPSAtRU5PTUVNOwogCQkJZ290byBmcmVlX29wcDsKQEAgLTUxOSwzNCArNTU5LDUzIEBACiAgKiBtdXRleCBjYW5ub3QgYmUgbG9ja2VkLgogICoKICAqIFJldHVybjoKLSAqIDA6CQlPbiBzdWNjZXNzIE9SCisgKiAwCQlPbiBzdWNjZXNzIE9SCiAgKgkJRHVwbGljYXRlIE9QUHMgKGJvdGggZnJlcSBhbmQgdm9sdCBhcmUgc2FtZSkgYW5kIG9wcC0+YXZhaWxhYmxlCi0gKiAtRUVYSVNUOglGcmVxIGFyZSBzYW1lIGFuZCB2b2x0IGFyZSBkaWZmZXJlbnQgT1IKKyAqIC1FRVhJU1QJRnJlcSBhcmUgc2FtZSBhbmQgdm9sdCBhcmUgZGlmZmVyZW50IE9SCiAgKgkJRHVwbGljYXRlIE9QUHMgKGJvdGggZnJlcSBhbmQgdm9sdCBhcmUgc2FtZSkgYW5kICFvcHAtPmF2YWlsYWJsZQotICogLUVOT01FTToJTWVtb3J5IGFsbG9jYXRpb24gZmFpbHVyZQorICogLUVOT01FTQlNZW1vcnkgYWxsb2NhdGlvbiBmYWlsdXJlCiAgKi8KIGludCBkZXZfcG1fb3BwX2FkZChzdHJ1Y3QgZGV2aWNlICpkZXYsIHVuc2lnbmVkIGxvbmcgZnJlcSwgdW5zaWduZWQgbG9uZyB1X3ZvbHQpCiB7Ci0JcmV0dXJuIGRldl9wbV9vcHBfYWRkX2R5bmFtaWMoZGV2LCBmcmVxLCB1X3ZvbHQsIHRydWUpOworCXJldHVybiBfb3BwX2FkZF9keW5hbWljKGRldiwgZnJlcSwgdV92b2x0LCB0cnVlKTsKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKGRldl9wbV9vcHBfYWRkKTsKIAotc3RhdGljIHZvaWQga2ZyZWVfb3BwX3JjdShzdHJ1Y3QgcmN1X2hlYWQgKmhlYWQpCisvKioKKyAqIF9rZnJlZV9vcHBfcmN1KCkgLSBGcmVlIE9QUCBSQ1UgaGFuZGxlcgorICogQGhlYWQ6CVJDVSBoZWFkCisgKi8KK3N0YXRpYyB2b2lkIF9rZnJlZV9vcHBfcmN1KHN0cnVjdCByY3VfaGVhZCAqaGVhZCkKIHsKIAlzdHJ1Y3QgZGV2X3BtX29wcCAqb3BwID0gY29udGFpbmVyX29mKGhlYWQsIHN0cnVjdCBkZXZfcG1fb3BwLCByY3VfaGVhZCk7CiAKIAlrZnJlZV9yY3Uob3BwLCByY3VfaGVhZCk7CiB9CiAKLXN0YXRpYyB2b2lkIGtmcmVlX2RldmljZV9yY3Uoc3RydWN0IHJjdV9oZWFkICpoZWFkKQorLyoqCisgKiBfa2ZyZWVfZGV2aWNlX3JjdSgpIC0gRnJlZSBkZXZpY2Vfb3BwIFJDVSBoYW5kbGVyCisgKiBAaGVhZDoJUkNVIGhlYWQKKyAqLworc3RhdGljIHZvaWQgX2tmcmVlX2RldmljZV9yY3Uoc3RydWN0IHJjdV9oZWFkICpoZWFkKQogewogCXN0cnVjdCBkZXZpY2Vfb3BwICpkZXZpY2Vfb3BwID0gY29udGFpbmVyX29mKGhlYWQsIHN0cnVjdCBkZXZpY2Vfb3BwLCByY3VfaGVhZCk7CiAKIAlrZnJlZV9yY3UoZGV2aWNlX29wcCwgcmN1X2hlYWQpOwogfQogCi1zdGF0aWMgdm9pZCBfX2Rldl9wbV9vcHBfcmVtb3ZlKHN0cnVjdCBkZXZpY2Vfb3BwICpkZXZfb3BwLAotCQkJCXN0cnVjdCBkZXZfcG1fb3BwICpvcHApCisvKioKKyAqIF9vcHBfcmVtb3ZlKCkgIC0gUmVtb3ZlIGFuIE9QUCBmcm9tIGEgdGFibGUgZGVmaW5pdGlvbgorICogQGRldl9vcHA6CXBvaW50cyBiYWNrIHRvIHRoZSBkZXZpY2Vfb3BwIHN0cnVjdCB0aGlzIG9wcCBiZWxvbmdzIHRvCisgKiBAb3BwOglwb2ludGVyIHRvIHRoZSBPUFAgdG8gcmVtb3ZlCisgKgorICogVGhpcyBmdW5jdGlvbiByZW1vdmVzIGFuIG9wcCBkZWZpbml0aW9uIGZyb20gdGhlIG9wcCBsaXN0LgorICoKKyAqIExvY2tpbmc6IFRoZSBpbnRlcm5hbCBkZXZpY2Vfb3BwIGFuZCBvcHAgc3RydWN0dXJlcyBhcmUgUkNVIHByb3RlY3RlZC4KKyAqIEl0IGlzIGFzc3VtZWQgdGhhdCB0aGUgY2FsbGVyIGhvbGRzIHJlcXVpcmVkIG11dGV4IGZvciBhbiBSQ1UgdXBkYXRlcgorICogc3RyYXRlZ3kuCisgKi8KK3N0YXRpYyB2b2lkIF9vcHBfcmVtb3ZlKHN0cnVjdCBkZXZpY2Vfb3BwICpkZXZfb3BwLAorCQkJc3RydWN0IGRldl9wbV9vcHAgKm9wcCkKIHsKIAkvKgogCSAqIE5vdGlmeSB0aGUgY2hhbmdlcyBpbiB0aGUgYXZhaWxhYmlsaXR5IG9mIHRoZSBvcGVyYWJsZQpAQCAtNTU0LDEyICs2MTMsMTIgQEAKIAkgKi8KIAlzcmN1X25vdGlmaWVyX2NhbGxfY2hhaW4oJmRldl9vcHAtPnNyY3VfaGVhZCwgT1BQX0VWRU5UX1JFTU9WRSwgb3BwKTsKIAlsaXN0X2RlbF9yY3UoJm9wcC0+bm9kZSk7Ci0JY2FsbF9zcmN1KCZkZXZfb3BwLT5zcmN1X2hlYWQuc3JjdSwgJm9wcC0+cmN1X2hlYWQsIGtmcmVlX29wcF9yY3UpOworCWNhbGxfc3JjdSgmZGV2X29wcC0+c3JjdV9oZWFkLnNyY3UsICZvcHAtPnJjdV9oZWFkLCBfa2ZyZWVfb3BwX3JjdSk7CiAKIAlpZiAobGlzdF9lbXB0eSgmZGV2X29wcC0+b3BwX2xpc3QpKSB7CiAJCWxpc3RfZGVsX3JjdSgmZGV2X29wcC0+bm9kZSk7CiAJCWNhbGxfc3JjdSgmZGV2X29wcC0+c3JjdV9oZWFkLnNyY3UsICZkZXZfb3BwLT5yY3VfaGVhZCwKLQkJCSAga2ZyZWVfZGV2aWNlX3JjdSk7CisJCQkgIF9rZnJlZV9kZXZpY2VfcmN1KTsKIAl9CiB9CiAKQEAgLTU2OSw2ICs2MjgsMTIgQEAKICAqIEBmcmVxOglPUFAgdG8gcmVtb3ZlIHdpdGggbWF0Y2hpbmcgJ2ZyZXEnCiAgKgogICogVGhpcyBmdW5jdGlvbiByZW1vdmVzIGFuIG9wcCBmcm9tIHRoZSBvcHAgbGlzdC4KKyAqCisgKiBMb2NraW5nOiBUaGUgaW50ZXJuYWwgZGV2aWNlX29wcCBhbmQgb3BwIHN0cnVjdHVyZXMgYXJlIFJDVSBwcm90ZWN0ZWQuCisgKiBIZW5jZSB0aGlzIGZ1bmN0aW9uIGludGVybmFsbHkgdXNlcyBSQ1UgdXBkYXRlciBzdHJhdGVneSB3aXRoIG11dGV4IGxvY2tzCisgKiB0byBrZWVwIHRoZSBpbnRlZ3JpdHkgb2YgdGhlIGludGVybmFsIGRhdGEgc3RydWN0dXJlcy4gQ2FsbGVycyBzaG91bGQgZW5zdXJlCisgKiB0aGF0IHRoaXMgZnVuY3Rpb24gaXMgKk5PVCogY2FsbGVkIHVuZGVyIFJDVSBwcm90ZWN0aW9uIG9yIGluIGNvbnRleHRzIHdoZXJlCisgKiBtdXRleCBjYW5ub3QgYmUgbG9ja2VkLgogICovCiB2b2lkIGRldl9wbV9vcHBfcmVtb3ZlKHN0cnVjdCBkZXZpY2UgKmRldiwgdW5zaWduZWQgbG9uZyBmcmVxKQogewpAQCAtNTc5LDcgKzY0NCw3IEBACiAJLyogSG9sZCBvdXIgbGlzdCBtb2RpZmljYXRpb24gbG9jayBoZXJlICovCiAJbXV0ZXhfbG9jaygmZGV2X29wcF9saXN0X2xvY2spOwogCi0JZGV2X29wcCA9IGZpbmRfZGV2aWNlX29wcChkZXYpOworCWRldl9vcHAgPSBfZmluZF9kZXZpY2Vfb3BwKGRldik7CiAJaWYgKElTX0VSUihkZXZfb3BwKSkKIAkJZ290byB1bmxvY2s7CiAKQEAgLTU5NiwxNCArNjYxLDE0IEBACiAJCWdvdG8gdW5sb2NrOwogCX0KIAotCV9fZGV2X3BtX29wcF9yZW1vdmUoZGV2X29wcCwgb3BwKTsKKwlfb3BwX3JlbW92ZShkZXZfb3BwLCBvcHApOwogdW5sb2NrOgogCW11dGV4X3VubG9jaygmZGV2X29wcF9saXN0X2xvY2spOwogfQogRVhQT1JUX1NZTUJPTF9HUEwoZGV2X3BtX29wcF9yZW1vdmUpOwogCiAvKioKLSAqIG9wcF9zZXRfYXZhaWxhYmlsaXR5KCkgLSBoZWxwZXIgdG8gc2V0IHRoZSBhdmFpbGFiaWxpdHkgb2YgYW4gb3BwCisgKiBfb3BwX3NldF9hdmFpbGFiaWxpdHkoKSAtIGhlbHBlciB0byBzZXQgdGhlIGF2YWlsYWJpbGl0eSBvZiBhbiBvcHAKICAqIEBkZXY6CQlkZXZpY2UgZm9yIHdoaWNoIHdlIGRvIHRoaXMgb3BlcmF0aW9uCiAgKiBAZnJlcToJCU9QUCBmcmVxdWVuY3kgdG8gbW9kaWZ5IGF2YWlsYWJpbGl0eQogICogQGF2YWlsYWJpbGl0eV9yZXE6CWF2YWlsYWJpbGl0eSBzdGF0dXMgcmVxdWVzdGVkIGZvciB0aGlzIG9wcApAQCAtNjExLDcgKzY3Niw3IEBACiAgKiBTZXQgdGhlIGF2YWlsYWJpbGl0eSBvZiBhbiBPUFAgd2l0aCBhbiBSQ1Ugb3BlcmF0aW9uLCBvcHBfe2VuYWJsZSxkaXNhYmxlfQogICogc2hhcmUgYSBjb21tb24gbG9naWMgd2hpY2ggaXMgaXNvbGF0ZWQgaGVyZS4KICAqCi0gKiBSZXR1cm5zIC1FSU5WQUwgZm9yIGJhZCBwb2ludGVycywgLUVOT01FTSBpZiBubyBtZW1vcnkgYXZhaWxhYmxlIGZvciB0aGUKKyAqIFJldHVybjogLUVJTlZBTCBmb3IgYmFkIHBvaW50ZXJzLCAtRU5PTUVNIGlmIG5vIG1lbW9yeSBhdmFpbGFibGUgZm9yIHRoZQogICogY29weSBvcGVyYXRpb24sIHJldHVybnMgMCBpZiBubyBtb2RpZmNhdGlvbiB3YXMgZG9uZSBPUiBtb2RpZmljYXRpb24gd2FzCiAgKiBzdWNjZXNzZnVsLgogICoKQEAgLTYyMSw4ICs2ODYsOCBAQAogICogdGhhdCB0aGlzIGZ1bmN0aW9uIGlzICpOT1QqIGNhbGxlZCB1bmRlciBSQ1UgcHJvdGVjdGlvbiBvciBpbiBjb250ZXh0cyB3aGVyZQogICogbXV0ZXggbG9ja2luZyBvciBzeW5jaHJvbml6ZV9yY3UoKSBibG9ja2luZyBjYWxscyBjYW5ub3QgYmUgdXNlZC4KICAqLwotc3RhdGljIGludCBvcHBfc2V0X2F2YWlsYWJpbGl0eShzdHJ1Y3QgZGV2aWNlICpkZXYsIHVuc2lnbmVkIGxvbmcgZnJlcSwKLQkJYm9vbCBhdmFpbGFiaWxpdHlfcmVxKQorc3RhdGljIGludCBfb3BwX3NldF9hdmFpbGFiaWxpdHkoc3RydWN0IGRldmljZSAqZGV2LCB1bnNpZ25lZCBsb25nIGZyZXEsCisJCQkJIGJvb2wgYXZhaWxhYmlsaXR5X3JlcSkKIHsKIAlzdHJ1Y3QgZGV2aWNlX29wcCAqZGV2X29wcDsKIAlzdHJ1Y3QgZGV2X3BtX29wcCAqbmV3X29wcCwgKnRtcF9vcHAsICpvcHAgPSBFUlJfUFRSKC1FTk9ERVYpOwpAQCAtNjM4LDcgKzcwMyw3IEBACiAJbXV0ZXhfbG9jaygmZGV2X29wcF9saXN0X2xvY2spOwogCiAJLyogRmluZCB0aGUgZGV2aWNlX29wcCAqLwotCWRldl9vcHAgPSBmaW5kX2RldmljZV9vcHAoZGV2KTsKKwlkZXZfb3BwID0gX2ZpbmRfZGV2aWNlX29wcChkZXYpOwogCWlmIChJU19FUlIoZGV2X29wcCkpIHsKIAkJciA9IFBUUl9FUlIoZGV2X29wcCk7CiAJCWRldl93YXJuKGRldiwgIiVzOiBEZXZpY2UgT1BQIG5vdCBmb3VuZCAoJWQpXG4iLCBfX2Z1bmNfXywgcik7CkBAIC02NjgsNyArNzMzLDcgQEAKIAogCWxpc3RfcmVwbGFjZV9yY3UoJm9wcC0+bm9kZSwgJm5ld19vcHAtPm5vZGUpOwogCW11dGV4X3VubG9jaygmZGV2X29wcF9saXN0X2xvY2spOwotCWNhbGxfc3JjdSgmZGV2X29wcC0+c3JjdV9oZWFkLnNyY3UsICZvcHAtPnJjdV9oZWFkLCBrZnJlZV9vcHBfcmN1KTsKKwljYWxsX3NyY3UoJmRldl9vcHAtPnNyY3VfaGVhZC5zcmN1LCAmb3BwLT5yY3VfaGVhZCwgX2tmcmVlX29wcF9yY3UpOwogCiAJLyogTm90aWZ5IHRoZSBjaGFuZ2Ugb2YgdGhlIE9QUCBhdmFpbGFiaWxpdHkgKi8KIAlpZiAoYXZhaWxhYmlsaXR5X3JlcSkKQEAgLTcwMCwxMCArNzY1LDE0IEBACiAgKiBpbnRlZ3JpdHkgb2YgdGhlIGludGVybmFsIGRhdGEgc3RydWN0dXJlcy4gQ2FsbGVycyBzaG91bGQgZW5zdXJlIHRoYXQKICAqIHRoaXMgZnVuY3Rpb24gaXMgKk5PVCogY2FsbGVkIHVuZGVyIFJDVSBwcm90ZWN0aW9uIG9yIGluIGNvbnRleHRzIHdoZXJlCiAgKiBtdXRleCBsb2NraW5nIG9yIHN5bmNocm9uaXplX3JjdSgpIGJsb2NraW5nIGNhbGxzIGNhbm5vdCBiZSB1c2VkLgorICoKKyAqIFJldHVybjogLUVJTlZBTCBmb3IgYmFkIHBvaW50ZXJzLCAtRU5PTUVNIGlmIG5vIG1lbW9yeSBhdmFpbGFibGUgZm9yIHRoZQorICogY29weSBvcGVyYXRpb24sIHJldHVybnMgMCBpZiBubyBtb2RpZmNhdGlvbiB3YXMgZG9uZSBPUiBtb2RpZmljYXRpb24gd2FzCisgKiBzdWNjZXNzZnVsLgogICovCiBpbnQgZGV2X3BtX29wcF9lbmFibGUoc3RydWN0IGRldmljZSAqZGV2LCB1bnNpZ25lZCBsb25nIGZyZXEpCiB7Ci0JcmV0dXJuIG9wcF9zZXRfYXZhaWxhYmlsaXR5KGRldiwgZnJlcSwgdHJ1ZSk7CisJcmV0dXJuIF9vcHBfc2V0X2F2YWlsYWJpbGl0eShkZXYsIGZyZXEsIHRydWUpOwogfQogRVhQT1JUX1NZTUJPTF9HUEwoZGV2X3BtX29wcF9lbmFibGUpOwogCkBAIC03MjIsMjYgKzc5MSw0MSBAQAogICogaW50ZWdyaXR5IG9mIHRoZSBpbnRlcm5hbCBkYXRhIHN0cnVjdHVyZXMuIENhbGxlcnMgc2hvdWxkIGVuc3VyZSB0aGF0CiAgKiB0aGlzIGZ1bmN0aW9uIGlzICpOT1QqIGNhbGxlZCB1bmRlciBSQ1UgcHJvdGVjdGlvbiBvciBpbiBjb250ZXh0cyB3aGVyZQogICogbXV0ZXggbG9ja2luZyBvciBzeW5jaHJvbml6ZV9yY3UoKSBibG9ja2luZyBjYWxscyBjYW5ub3QgYmUgdXNlZC4KKyAqCisgKiBSZXR1cm46IC1FSU5WQUwgZm9yIGJhZCBwb2ludGVycywgLUVOT01FTSBpZiBubyBtZW1vcnkgYXZhaWxhYmxlIGZvciB0aGUKKyAqIGNvcHkgb3BlcmF0aW9uLCByZXR1cm5zIDAgaWYgbm8gbW9kaWZjYXRpb24gd2FzIGRvbmUgT1IgbW9kaWZpY2F0aW9uIHdhcworICogc3VjY2Vzc2Z1bC4KICAqLwogaW50IGRldl9wbV9vcHBfZGlzYWJsZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHVuc2lnbmVkIGxvbmcgZnJlcSkKIHsKLQlyZXR1cm4gb3BwX3NldF9hdmFpbGFiaWxpdHkoZGV2LCBmcmVxLCBmYWxzZSk7CisJcmV0dXJuIF9vcHBfc2V0X2F2YWlsYWJpbGl0eShkZXYsIGZyZXEsIGZhbHNlKTsKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKGRldl9wbV9vcHBfZGlzYWJsZSk7CiAKIC8qKgogICogZGV2X3BtX29wcF9nZXRfbm90aWZpZXIoKSAtIGZpbmQgbm90aWZpZXJfaGVhZCBvZiB0aGUgZGV2aWNlIHdpdGggb3BwCiAgKiBAZGV2OglkZXZpY2UgcG9pbnRlciB1c2VkIHRvIGxvb2t1cCBkZXZpY2UgT1BQcy4KKyAqCisgKiBSZXR1cm46IHBvaW50ZXIgdG8gIG5vdGlmaWVyIGhlYWQgaWYgZm91bmQsIG90aGVyd2lzZSAtRU5PREVWIG9yCisgKiAtRUlOVkFMIGJhc2VkIG9uIHR5cGUgb2YgZXJyb3IgY2FzdGVkIGFzIHBvaW50ZXIuIHZhbHVlIG11c3QgYmUgY2hlY2tlZAorICogIHdpdGggSVNfRVJSIHRvIGRldGVybWluZSB2YWxpZCBwb2ludGVyIG9yIGVycm9yIHJlc3VsdC4KKyAqCisgKiBMb2NraW5nOiBUaGlzIGZ1bmN0aW9uIG11c3QgYmUgY2FsbGVkIHVuZGVyIHJjdV9yZWFkX2xvY2soKS4gZGV2X29wcCBpcyBhIFJDVQorICogcHJvdGVjdGVkIHBvaW50ZXIuIFRoZSByZWFzb24gZm9yIHRoZSBzYW1lIGlzIHRoYXQgdGhlIG9wcCBwb2ludGVyIHdoaWNoIGlzCisgKiByZXR1cm5lZCB3aWxsIHJlbWFpbiB2YWxpZCBmb3IgdXNlIHdpdGggb3BwX2dldF97dm9sdGFnZSwgZnJlcX0gb25seSB3aGlsZQorICogdW5kZXIgdGhlIGxvY2tlZCBhcmVhLiBUaGUgcG9pbnRlciByZXR1cm5lZCBtdXN0IGJlIHVzZWQgcHJpb3IgdG8gdW5sb2NraW5nCisgKiB3aXRoIHJjdV9yZWFkX3VubG9jaygpIHRvIG1haW50YWluIHRoZSBpbnRlZ3JpdHkgb2YgdGhlIHBvaW50ZXIuCiAgKi8KIHN0cnVjdCBzcmN1X25vdGlmaWVyX2hlYWQgKmRldl9wbV9vcHBfZ2V0X25vdGlmaWVyKHN0cnVjdCBkZXZpY2UgKmRldikKIHsKLQlzdHJ1Y3QgZGV2aWNlX29wcCAqZGV2X29wcCA9IGZpbmRfZGV2aWNlX29wcChkZXYpOworCXN0cnVjdCBkZXZpY2Vfb3BwICpkZXZfb3BwID0gX2ZpbmRfZGV2aWNlX29wcChkZXYpOwogCiAJaWYgKElTX0VSUihkZXZfb3BwKSkKIAkJcmV0dXJuIEVSUl9DQVNUKGRldl9vcHApOyAvKiBtYXRjaGluZyB0eXBlICovCiAKIAlyZXR1cm4gJmRldl9vcHAtPnNyY3VfaGVhZDsKIH0KK0VYUE9SVF9TWU1CT0xfR1BMKGRldl9wbV9vcHBfZ2V0X25vdGlmaWVyKTsKIAogI2lmZGVmIENPTkZJR19PRgogLyoqCkBAIC03NDksNiArODMzLDIyIEBACiAgKiBAZGV2OglkZXZpY2UgcG9pbnRlciB1c2VkIHRvIGxvb2t1cCBkZXZpY2UgT1BQcy4KICAqCiAgKiBSZWdpc3RlciB0aGUgaW5pdGlhbCBPUFAgdGFibGUgd2l0aCB0aGUgT1BQIGxpYnJhcnkgZm9yIGdpdmVuIGRldmljZS4KKyAqCisgKiBMb2NraW5nOiBUaGUgaW50ZXJuYWwgZGV2aWNlX29wcCBhbmQgb3BwIHN0cnVjdHVyZXMgYXJlIFJDVSBwcm90ZWN0ZWQuCisgKiBIZW5jZSB0aGlzIGZ1bmN0aW9uIGluZGlyZWN0bHkgdXNlcyBSQ1UgdXBkYXRlciBzdHJhdGVneSB3aXRoIG11dGV4IGxvY2tzCisgKiB0byBrZWVwIHRoZSBpbnRlZ3JpdHkgb2YgdGhlIGludGVybmFsIGRhdGEgc3RydWN0dXJlcy4gQ2FsbGVycyBzaG91bGQgZW5zdXJlCisgKiB0aGF0IHRoaXMgZnVuY3Rpb24gaXMgKk5PVCogY2FsbGVkIHVuZGVyIFJDVSBwcm90ZWN0aW9uIG9yIGluIGNvbnRleHRzIHdoZXJlCisgKiBtdXRleCBjYW5ub3QgYmUgbG9ja2VkLgorICoKKyAqIFJldHVybjoKKyAqIDAJCU9uIHN1Y2Nlc3MgT1IKKyAqCQlEdXBsaWNhdGUgT1BQcyAoYm90aCBmcmVxIGFuZCB2b2x0IGFyZSBzYW1lKSBhbmQgb3BwLT5hdmFpbGFibGUKKyAqIC1FRVhJU1QJRnJlcSBhcmUgc2FtZSBhbmQgdm9sdCBhcmUgZGlmZmVyZW50IE9SCisgKgkJRHVwbGljYXRlIE9QUHMgKGJvdGggZnJlcSBhbmQgdm9sdCBhcmUgc2FtZSkgYW5kICFvcHAtPmF2YWlsYWJsZQorICogLUVOT01FTQlNZW1vcnkgYWxsb2NhdGlvbiBmYWlsdXJlCisgKiAtRU5PREVWCXdoZW4gJ29wZXJhdGluZy1wb2ludHMnIHByb3BlcnR5IGlzIG5vdCBmb3VuZCBvciBpcyBpbnZhbGlkIGRhdGEKKyAqCQlpbiBkZXZpY2Ugbm9kZS4KKyAqIC1FTk9EQVRBCXdoZW4gZW1wdHkgJ29wZXJhdGluZy1wb2ludHMnIHByb3BlcnR5IGlzIGZvdW5kCiAgKi8KIGludCBvZl9pbml0X29wcF90YWJsZShzdHJ1Y3QgZGV2aWNlICpkZXYpCiB7CkBAIC03NzcsNyArODc3LDcgQEAKIAkJdW5zaWduZWQgbG9uZyBmcmVxID0gYmUzMl90b19jcHVwKHZhbCsrKSAqIDEwMDA7CiAJCXVuc2lnbmVkIGxvbmcgdm9sdCA9IGJlMzJfdG9fY3B1cCh2YWwrKyk7CiAKLQkJaWYgKGRldl9wbV9vcHBfYWRkX2R5bmFtaWMoZGV2LCBmcmVxLCB2b2x0LCBmYWxzZSkpCisJCWlmIChfb3BwX2FkZF9keW5hbWljKGRldiwgZnJlcSwgdm9sdCwgZmFsc2UpKQogCQkJZGV2X3dhcm4oZGV2LCAiJXM6IEZhaWxlZCB0byBhZGQgT1BQICVsZFxuIiwKIAkJCQkgX19mdW5jX18sIGZyZXEpOwogCQluciAtPSAyOwpAQCAtNzkyLDYgKzg5MiwxMiBAQAogICogQGRldjoJZGV2aWNlIHBvaW50ZXIgdXNlZCB0byBsb29rdXAgZGV2aWNlIE9QUHMuCiAgKgogICogRnJlZSBPUFBzIGNyZWF0ZWQgdXNpbmcgc3RhdGljIGVudHJpZXMgcHJlc2VudCBpbiBEVC4KKyAqCisgKiBMb2NraW5nOiBUaGUgaW50ZXJuYWwgZGV2aWNlX29wcCBhbmQgb3BwIHN0cnVjdHVyZXMgYXJlIFJDVSBwcm90ZWN0ZWQuCisgKiBIZW5jZSB0aGlzIGZ1bmN0aW9uIGluZGlyZWN0bHkgdXNlcyBSQ1UgdXBkYXRlciBzdHJhdGVneSB3aXRoIG11dGV4IGxvY2tzCisgKiB0byBrZWVwIHRoZSBpbnRlZ3JpdHkgb2YgdGhlIGludGVybmFsIGRhdGEgc3RydWN0dXJlcy4gQ2FsbGVycyBzaG91bGQgZW5zdXJlCisgKiB0aGF0IHRoaXMgZnVuY3Rpb24gaXMgKk5PVCogY2FsbGVkIHVuZGVyIFJDVSBwcm90ZWN0aW9uIG9yIGluIGNvbnRleHRzIHdoZXJlCisgKiBtdXRleCBjYW5ub3QgYmUgbG9ja2VkLgogICovCiB2b2lkIG9mX2ZyZWVfb3BwX3RhYmxlKHN0cnVjdCBkZXZpY2UgKmRldikKIHsKQEAgLTc5OSw3ICs5MDUsNyBAQAogCXN0cnVjdCBkZXZfcG1fb3BwICpvcHAsICp0bXA7CiAKIAkvKiBDaGVjayBmb3IgZXhpc3RpbmcgbGlzdCBmb3IgJ2RldicgKi8KLQlkZXZfb3BwID0gZmluZF9kZXZpY2Vfb3BwKGRldik7CisJZGV2X29wcCA9IF9maW5kX2RldmljZV9vcHAoZGV2KTsKIAlpZiAoSVNfRVJSKGRldl9vcHApKSB7CiAJCWludCBlcnJvciA9IFBUUl9FUlIoZGV2X29wcCk7CiAJCWlmIChlcnJvciAhPSAtRU5PREVWKQpAQCAtODE2LDcgKzkyMiw3IEBACiAJLyogRnJlZSBzdGF0aWMgT1BQcyAqLwogCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShvcHAsIHRtcCwgJmRldl9vcHAtPm9wcF9saXN0LCBub2RlKSB7CiAJCWlmICghb3BwLT5keW5hbWljKQotCQkJX19kZXZfcG1fb3BwX3JlbW92ZShkZXZfb3BwLCBvcHApOworCQkJX29wcF9yZW1vdmUoZGV2X29wcCwgb3BwKTsKIAl9CiAKIAltdXRleF91bmxvY2soJmRldl9vcHBfbGlzdF9sb2NrKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYmFzZS9wb3dlci9xb3MuYyBiL2RyaXZlcnMvYmFzZS9wb3dlci9xb3MuYwppbmRleCBhOGZlNGMxLi5lNTZkNTM4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2Jhc2UvcG93ZXIvcW9zLmMKKysrIGIvZHJpdmVycy9iYXNlL3Bvd2VyL3Fvcy5jCkBAIC02NCw2ICs2NCw4IEBACiAJc3RydWN0IHBtX3Fvc19mbGFncyAqcHFmOwogCXMzMiB2YWw7CiAKKwlsb2NrZGVwX2Fzc2VydF9oZWxkKCZkZXYtPnBvd2VyLmxvY2spOworCiAJaWYgKElTX0VSUl9PUl9OVUxMKHFvcykpCiAJCXJldHVybiBQTV9RT1NfRkxBR1NfVU5ERUZJTkVEOwogCkBAIC0xMDQsNiArMTA2LDggQEAKICAqLwogczMyIF9fZGV2X3BtX3Fvc19yZWFkX3ZhbHVlKHN0cnVjdCBkZXZpY2UgKmRldikKIHsKKwlsb2NrZGVwX2Fzc2VydF9oZWxkKCZkZXYtPnBvd2VyLmxvY2spOworCiAJcmV0dXJuIElTX0VSUl9PUl9OVUxMKGRldi0+cG93ZXIucW9zKSA/CiAJCTAgOiBwbV9xb3NfcmVhZF92YWx1ZSgmZGV2LT5wb3dlci5xb3MtPnJlc3VtZV9sYXRlbmN5KTsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYmxvY2svbnZtZS1jb3JlLmMgYi9kcml2ZXJzL2Jsb2NrL252bWUtY29yZS5jCmluZGV4IGNiNTI5ZTkuLmQ4MjZiZjMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYmxvY2svbnZtZS1jb3JlLmMKKysrIGIvZHJpdmVycy9ibG9jay9udm1lLWNvcmUuYwpAQCAtMTA2LDcgKzEwNiw3IEBACiAJZG1hX2FkZHJfdCBjcV9kbWFfYWRkcjsKIAl1MzIgX19pb21lbSAqcV9kYjsKIAl1MTYgcV9kZXB0aDsKLQl1MTYgY3FfdmVjdG9yOworCXMxNiBjcV92ZWN0b3I7CiAJdTE2IHNxX2hlYWQ7CiAJdTE2IHNxX3RhaWw7CiAJdTE2IGNxX2hlYWQ7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL3JiZC5jIGIvZHJpdmVycy9ibG9jay9yYmQuYwppbmRleCAzZWM4NWRmLi44YTg2YjYyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2Jsb2NrL3JiZC5jCisrKyBiL2RyaXZlcnMvYmxvY2svcmJkLmMKQEAgLTIwOTgsMzIgKzIwOTgsMjYgQEAKICAqIElmIGFuIGltYWdlIGhhcyBhIG5vbi16ZXJvIHBhcmVudCBvdmVybGFwLCBnZXQgYSByZWZlcmVuY2UgdG8gaXRzCiAgKiBwYXJlbnQuCiAgKgotICogV2UgbXVzdCBnZXQgdGhlIHJlZmVyZW5jZSBiZWZvcmUgY2hlY2tpbmcgZm9yIHRoZSBvdmVybGFwIHRvCi0gKiBjb29yZGluYXRlIHByb3Blcmx5IHdpdGggemVyb2luZyB0aGUgcGFyZW50IG92ZXJsYXAgaW4KLSAqIHJiZF9kZXZfdjJfcGFyZW50X2luZm8oKSB3aGVuIGFuIGltYWdlIGdldHMgZmxhdHRlbmVkLiAgV2UKLSAqIGRyb3AgaXQgYWdhaW4gaWYgdGhlcmUgaXMgbm8gb3ZlcmxhcC4KLSAqCiAgKiBSZXR1cm5zIHRydWUgaWYgdGhlIHJiZCBkZXZpY2UgaGFzIGEgcGFyZW50IHdpdGggYSBub24temVybwogICogb3ZlcmxhcCBhbmQgYSByZWZlcmVuY2UgZm9yIGl0IHdhcyBzdWNjZXNzZnVsbHkgdGFrZW4sIG9yCiAgKiBmYWxzZSBvdGhlcndpc2UuCiAgKi8KIHN0YXRpYyBib29sIHJiZF9kZXZfcGFyZW50X2dldChzdHJ1Y3QgcmJkX2RldmljZSAqcmJkX2RldikKIHsKLQlpbnQgY291bnRlcjsKKwlpbnQgY291bnRlciA9IDA7CiAKIAlpZiAoIXJiZF9kZXYtPnBhcmVudF9zcGVjKQogCQlyZXR1cm4gZmFsc2U7CiAKLQljb3VudGVyID0gYXRvbWljX2luY19yZXR1cm5fc2FmZSgmcmJkX2Rldi0+cGFyZW50X3JlZik7Ci0JaWYgKGNvdW50ZXIgPiAwICYmIHJiZF9kZXYtPnBhcmVudF9vdmVybGFwKQotCQlyZXR1cm4gdHJ1ZTsKLQotCS8qIEltYWdlIHdhcyBmbGF0dGVuZWQsIGJ1dCBwYXJlbnQgaXMgbm90IHlldCB0b3JuIGRvd24gKi8KKwlkb3duX3JlYWQoJnJiZF9kZXYtPmhlYWRlcl9yd3NlbSk7CisJaWYgKHJiZF9kZXYtPnBhcmVudF9vdmVybGFwKQorCQljb3VudGVyID0gYXRvbWljX2luY19yZXR1cm5fc2FmZSgmcmJkX2Rldi0+cGFyZW50X3JlZik7CisJdXBfcmVhZCgmcmJkX2Rldi0+aGVhZGVyX3J3c2VtKTsKIAogCWlmIChjb3VudGVyIDwgMCkKIAkJcmJkX3dhcm4ocmJkX2RldiwgInBhcmVudCByZWZlcmVuY2Ugb3ZlcmZsb3ciKTsKIAotCXJldHVybiBmYWxzZTsKKwlyZXR1cm4gY291bnRlciA+IDA7CiB9CiAKIC8qCkBAIC00MjM5LDcgKzQyMzMsNiBAQAogCQkgKi8KIAkJaWYgKHJiZF9kZXYtPnBhcmVudF9vdmVybGFwKSB7CiAJCQlyYmRfZGV2LT5wYXJlbnRfb3ZlcmxhcCA9IDA7Ci0JCQlzbXBfbWIoKTsKIAkJCXJiZF9kZXZfcGFyZW50X3B1dChyYmRfZGV2KTsKIAkJCXByX2luZm8oIiVzOiBjbG9uZSBpbWFnZSBoYXMgYmVlbiBmbGF0dGVuZWRcbiIsCiAJCQkJcmJkX2Rldi0+ZGlzay0+ZGlza19uYW1lKTsKQEAgLTQyODUsNyArNDI3OCw2IEBACiAJICogdHJlYXQgaXQgc3BlY2lhbGx5LgogCSAqLwogCXJiZF9kZXYtPnBhcmVudF9vdmVybGFwID0gb3ZlcmxhcDsKLQlzbXBfbWIoKTsKIAlpZiAoIW92ZXJsYXApIHsKIAogCQkvKiBBIG51bGwgcGFyZW50X3NwZWMgaW5kaWNhdGVzIGl0J3MgdGhlIGluaXRpYWwgcHJvYmUgKi8KQEAgLTUxMTQsMTAgKzUxMDYsNyBAQAogewogCXN0cnVjdCByYmRfaW1hZ2VfaGVhZGVyCSpoZWFkZXI7CiAKLQkvKiBEcm9wIHBhcmVudCByZWZlcmVuY2UgdW5sZXNzIGl0J3MgYWxyZWFkeSBiZWVuIGRvbmUgKG9yIG5vbmUpICovCi0KLQlpZiAocmJkX2Rldi0+cGFyZW50X292ZXJsYXApCi0JCXJiZF9kZXZfcGFyZW50X3B1dChyYmRfZGV2KTsKKwlyYmRfZGV2X3BhcmVudF9wdXQocmJkX2Rldik7CiAKIAkvKiBGcmVlIGR5bmFtaWMgZmllbGRzIGZyb20gdGhlIGhlYWRlciwgdGhlbiB6ZXJvIGl0IG91dCAqLwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2J1cy9tdmVidS1tYnVzLmMgYi9kcml2ZXJzL2J1cy9tdmVidS1tYnVzLmMKaW5kZXggZWI3NjgyZC4uODFiZjI5NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9idXMvbXZlYnUtbWJ1cy5jCisrKyBiL2RyaXZlcnMvYnVzL212ZWJ1LW1idXMuYwpAQCAtMjEwLDEyICsyMTAsMjUgQEAKIH0KIAogLyogQ2hlY2tzIHdoZXRoZXIgdGhlIGdpdmVuIHdpbmRvdyBudW1iZXIgaXMgYXZhaWxhYmxlICovCisKKy8qIE9uIEFybWFkYSBYUCwgMzc1IGFuZCAzOHggdGhlIE1CdXMgd2luZG93IDEzIGhhcyB0aGUgcmVtYXAKKyAqIGNhcGFiaWxpdHksIGxpa2Ugd2luZG93cyAwIHRvIDcuIEhvd2V2ZXIsIHRoZSBtdmVidS1tYnVzIGRyaXZlcgorICogaXNuJ3QgY3VycmVudGx5IHRha2luZyBpbnRvIGFjY291bnQgdGhpcyBzcGVjaWFsIGNhc2UsIHdoaWNoIG1lYW5zCisgKiB0aGF0IHdoZW4gd2luZG93IDEzIGlzIGFjdHVhbGx5IHVzZWQsIHRoZSByZW1hcCByZWdpc3RlcnMgYXJlIGxlZnQKKyAqIHRvIDAsIG1ha2luZyB0aGUgZGV2aWNlIHVzaW5nIHRoaXMgTUJ1cyB3aW5kb3cgdW5hdmFpbGFibGUuIFRoZQorICogcXVpY2sgZml4IGZvciBzdGFibGUgaXMgdG8gbm90IHVzZSB3aW5kb3cgMTMuIEEgZm9sbG93IHVwIHBhdGNoCisgKiB3aWxsIGNvcnJlY3RseSBoYW5kbGUgdGhpcyB3aW5kb3cuCisqLwogc3RhdGljIGludCBtdmVidV9tYnVzX3dpbmRvd19pc19mcmVlKHN0cnVjdCBtdmVidV9tYnVzX3N0YXRlICptYnVzLAogCQkJCSAgICAgY29uc3QgaW50IHdpbikKIHsKIAl2b2lkIF9faW9tZW0gKmFkZHIgPSBtYnVzLT5tYnVzd2luc19iYXNlICsKIAkJbWJ1cy0+c29jLT53aW5fY2ZnX29mZnNldCh3aW4pOwogCXUzMiBjdHJsID0gcmVhZGwoYWRkciArIFdJTl9DVFJMX09GRik7CisKKwlpZiAod2luID09IDEzKQorCQlyZXR1cm4gZmFsc2U7CisKIAlyZXR1cm4gIShjdHJsICYgV0lOX0NUUkxfRU5BQkxFKTsKIH0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9jaGFyL2hwZXQuYyBiL2RyaXZlcnMvY2hhci9ocGV0LmMKaW5kZXggZDVkNGNkOC4uNWMwYmFhOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9jaGFyL2hwZXQuYworKysgYi9kcml2ZXJzL2NoYXIvaHBldC5jCkBAIC05NzYsOCArOTc2LDggQEAKIAlzdGF0dXMgPSBhY3BpX3Jlc291cmNlX3RvX2FkZHJlc3M2NChyZXMsICZhZGRyKTsKIAogCWlmIChBQ1BJX1NVQ0NFU1Moc3RhdHVzKSkgewotCQloZHAtPmhkX3BoeXNfYWRkcmVzcyA9IGFkZHIubWluaW11bTsKLQkJaGRwLT5oZF9hZGRyZXNzID0gaW9yZW1hcChhZGRyLm1pbmltdW0sIGFkZHIuYWRkcmVzc19sZW5ndGgpOworCQloZHAtPmhkX3BoeXNfYWRkcmVzcyA9IGFkZHIuYWRkcmVzcy5taW5pbXVtOworCQloZHAtPmhkX2FkZHJlc3MgPSBpb3JlbWFwKGFkZHIuYWRkcmVzcy5taW5pbXVtLCBhZGRyLmFkZHJlc3MuYWRkcmVzc19sZW5ndGgpOwogCiAJCWlmIChocGV0X2lzX2tub3duKGhkcCkpIHsKIAkJCWlvdW5tYXAoaGRwLT5oZF9hZGRyZXNzKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2xvY2tzb3VyY2UvYmNtX2tvbmFfdGltZXIuYyBiL2RyaXZlcnMvY2xvY2tzb3VyY2UvYmNtX2tvbmFfdGltZXIuYwppbmRleCAwNTk1ZGM2Li5mMWUzM2QwIDEwMDY0NAotLS0gYS9kcml2ZXJzL2Nsb2Nrc291cmNlL2JjbV9rb25hX3RpbWVyLmMKKysrIGIvZHJpdmVycy9jbG9ja3NvdXJjZS9iY21fa29uYV90aW1lci5jCkBAIC02OCw5ICs2OCw4IEBACiB9CiAKIHN0YXRpYyB2b2lkCi1rb25hX3RpbWVyX2dldF9jb3VudGVyKHZvaWQgKnRpbWVyX2Jhc2UsIHVpbnQzMl90ICptc3csIHVpbnQzMl90ICpsc3cpCitrb25hX3RpbWVyX2dldF9jb3VudGVyKHZvaWQgX19pb21lbSAqdGltZXJfYmFzZSwgdWludDMyX3QgKm1zdywgdWludDMyX3QgKmxzdykKIHsKLQl2b2lkIF9faW9tZW0gKmJhc2UgPSBJT01FTSh0aW1lcl9iYXNlKTsKIAlpbnQgbG9vcF9saW1pdCA9IDQ7CiAKIAkvKgpAQCAtODYsOSArODUsOSBAQAogCSAqLwogCiAJd2hpbGUgKC0tbG9vcF9saW1pdCkgewotCQkqbXN3ID0gcmVhZGwoYmFzZSArIEtPTkFfR1BUSU1FUl9TVENISV9PRkZTRVQpOwotCQkqbHN3ID0gcmVhZGwoYmFzZSArIEtPTkFfR1BUSU1FUl9TVENMT19PRkZTRVQpOwotCQlpZiAoKm1zdyA9PSByZWFkbChiYXNlICsgS09OQV9HUFRJTUVSX1NUQ0hJX09GRlNFVCkpCisJCSptc3cgPSByZWFkbCh0aW1lcl9iYXNlICsgS09OQV9HUFRJTUVSX1NUQ0hJX09GRlNFVCk7CisJCSpsc3cgPSByZWFkbCh0aW1lcl9iYXNlICsgS09OQV9HUFRJTUVSX1NUQ0xPX09GRlNFVCk7CisJCWlmICgqbXN3ID09IHJlYWRsKHRpbWVyX2Jhc2UgKyBLT05BX0dQVElNRVJfU1RDSElfT0ZGU0VUKSkKIAkJCWJyZWFrOwogCX0KIAlpZiAoIWxvb3BfbGltaXQpIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2xvY2tzb3VyY2UvZXh5bm9zX21jdC5jIGIvZHJpdmVycy9jbG9ja3NvdXJjZS9leHlub3NfbWN0LmMKaW5kZXggOTQwMzA2MS4uODM1NjRjOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9jbG9ja3NvdXJjZS9leHlub3NfbWN0LmMKKysrIGIvZHJpdmVycy9jbG9ja3NvdXJjZS9leHlub3NfbWN0LmMKQEAgLTk3LDggKzk3LDggQEAKIAl3cml0ZWxfcmVsYXhlZCh2YWx1ZSwgcmVnX2Jhc2UgKyBvZmZzZXQpOwogCiAJaWYgKGxpa2VseShvZmZzZXQgPj0gRVhZTk9TNF9NQ1RfTF9CQVNFKDApKSkgewotCQlzdGF0X2FkZHIgPSAob2Zmc2V0ICYgfkVYWU5PUzRfTUNUX0xfTUFTSykgKyBNQ1RfTF9XU1RBVF9PRkZTRVQ7Ci0JCXN3aXRjaCAob2Zmc2V0ICYgRVhZTk9TNF9NQ1RfTF9NQVNLKSB7CisJCXN0YXRfYWRkciA9IChvZmZzZXQgJiBFWFlOT1M0X01DVF9MX01BU0spICsgTUNUX0xfV1NUQVRfT0ZGU0VUOworCQlzd2l0Y2ggKG9mZnNldCAmIH5FWFlOT1M0X01DVF9MX01BU0spIHsKIAkJY2FzZSBNQ1RfTF9UQ09OX09GRlNFVDoKIAkJCW1hc2sgPSAxIDw8IDM7CQkvKiBMX1RDT04gd3JpdGUgc3RhdHVzICovCiAJCQlicmVhazsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2xvY2tzb3VyY2Uvc2hfdG11LmMgYi9kcml2ZXJzL2Nsb2Nrc291cmNlL3NoX3RtdS5jCmluZGV4IDBmNjY1YjguLmYxNTBjYTgyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2Nsb2Nrc291cmNlL3NoX3RtdS5jCisrKyBiL2RyaXZlcnMvY2xvY2tzb3VyY2Uvc2hfdG11LmMKQEAgLTQyOCw3ICs0MjgsNyBAQAogCWNlZC0+ZmVhdHVyZXMgPSBDTE9DS19FVlRfRkVBVF9QRVJJT0RJQzsKIAljZWQtPmZlYXR1cmVzIHw9IENMT0NLX0VWVF9GRUFUX09ORVNIT1Q7CiAJY2VkLT5yYXRpbmcgPSAyMDA7Ci0JY2VkLT5jcHVtYXNrID0gY3B1bWFza19vZigwKTsKKwljZWQtPmNwdW1hc2sgPSBjcHVfcG9zc2libGVfbWFzazsKIAljZWQtPnNldF9uZXh0X2V2ZW50ID0gc2hfdG11X2Nsb2NrX2V2ZW50X25leHQ7CiAJY2VkLT5zZXRfbW9kZSA9IHNoX3RtdV9jbG9ja19ldmVudF9tb2RlOwogCWNlZC0+c3VzcGVuZCA9IHNoX3RtdV9jbG9ja19ldmVudF9zdXNwZW5kOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9jcHVpZGxlL2NwdWlkbGUtYmlnX2xpdHRsZS5jIGIvZHJpdmVycy9jcHVpZGxlL2NwdWlkbGUtYmlnX2xpdHRsZS5jCmluZGV4IGUzZTIyNWYuLjQwYzM0ZmEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY3B1aWRsZS9jcHVpZGxlLWJpZ19saXR0bGUuYworKysgYi9kcml2ZXJzL2NwdWlkbGUvY3B1aWRsZS1iaWdfbGl0dGxlLmMKQEAgLTE4Miw2ICsxODIsMTAgQEAKIAkgKi8KIAlpZiAoIW9mX21hdGNoX25vZGUoY29tcGF0aWJsZV9tYWNoaW5lX21hdGNoLCByb290KSkKIAkJcmV0dXJuIC1FTk9ERVY7CisKKwlpZiAoIW1jcG1faXNfYXZhaWxhYmxlKCkpCisJCXJldHVybiAtRVVOQVRDSDsKKwogCS8qCiAJICogRm9yIG5vdyB0aGUgZGlmZmVyZW50aWF0aW9uIGJldHdlZW4gbGl0dGxlIGFuZCBiaWcgY29yZXMKIAkgKiBpcyBiYXNlZCBvbiB0aGUgcGFydCBudW1iZXIuIEE3IGNvcmVzIGFyZSBjb25zaWRlcmVkIGxpdHRsZQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9kZXZmcmVxL0tjb25maWcgYi9kcml2ZXJzL2RldmZyZXEvS2NvbmZpZwppbmRleCBmYWY0ZTcwLi41MWRjY2IzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2RldmZyZXEvS2NvbmZpZworKysgYi9kcml2ZXJzL2RldmZyZXEvS2NvbmZpZwpAQCAtODcsNCArODcsMTYgQEAKIAkgIEl0IHJlYWRzIFBQTVUgY291bnRlcnMgb2YgbWVtb3J5IGNvbnRyb2xsZXJzIGFuZCBhZGp1c3RzIHRoZQogCSAgb3BlcmF0aW5nIGZyZXF1ZW5jaWVzIGFuZCB2b2x0YWdlcyB3aXRoIE9QUCBzdXBwb3J0LgogCitjb25maWcgQVJNX1RFR1JBX0RFVkZSRVEKKyAgICAgICB0cmlzdGF0ZSAiVGVncmEgREVWRlJFUSBEcml2ZXIiCisgICAgICAgZGVwZW5kcyBvbiBBUkNIX1RFR1JBXzEyNF9TT0MKKyAgICAgICBzZWxlY3QgREVWRlJFUV9HT1ZfU0lNUExFX09OREVNQU5ECisgICAgICAgc2VsZWN0IFBNX09QUAorICAgICAgIGhlbHAKKyAgICAgICAgIFRoaXMgYWRkcyB0aGUgREVWRlJFUSBkcml2ZXIgZm9yIHRoZSBUZWdyYSBmYW1pbHkgb2YgU29Dcy4KKyAgICAgICAgIEl0IHJlYWRzIEFDVE1PTiBjb3VudGVycyBvZiBtZW1vcnkgY29udHJvbGxlcnMgYW5kIGFkanVzdHMgdGhlCisgICAgICAgICBvcGVyYXRpbmcgZnJlcXVlbmNpZXMgYW5kIHZvbHRhZ2VzIHdpdGggT1BQIHN1cHBvcnQuCisKK3NvdXJjZSAiZHJpdmVycy9kZXZmcmVxL2V2ZW50L0tjb25maWciCisKIGVuZGlmICMgUE1fREVWRlJFUQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9kZXZmcmVxL01ha2VmaWxlIGIvZHJpdmVycy9kZXZmcmVxL01ha2VmaWxlCmluZGV4IDE2MTM4YzkuLjUxMzRmOWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZGV2ZnJlcS9NYWtlZmlsZQorKysgYi9kcml2ZXJzL2RldmZyZXEvTWFrZWZpbGUKQEAgLTEsNCArMSw1IEBACiBvYmotJChDT05GSUdfUE1fREVWRlJFUSkJKz0gZGV2ZnJlcS5vCitvYmotJChDT05GSUdfUE1fREVWRlJFUV9FVkVOVCkJKz0gZGV2ZnJlcS1ldmVudC5vCiBvYmotJChDT05GSUdfREVWRlJFUV9HT1ZfU0lNUExFX09OREVNQU5EKQkrPSBnb3Zlcm5vcl9zaW1wbGVvbmRlbWFuZC5vCiBvYmotJChDT05GSUdfREVWRlJFUV9HT1ZfUEVSRk9STUFOQ0UpCSs9IGdvdmVybm9yX3BlcmZvcm1hbmNlLm8KIG9iai0kKENPTkZJR19ERVZGUkVRX0dPVl9QT1dFUlNBVkUpCSs9IGdvdmVybm9yX3Bvd2Vyc2F2ZS5vCkBAIC03LDMgKzgsNyBAQAogIyBERVZGUkVRIERyaXZlcnMKIG9iai0kKENPTkZJR19BUk1fRVhZTk9TNF9CVVNfREVWRlJFUSkJKz0gZXh5bm9zLwogb2JqLSQoQ09ORklHX0FSTV9FWFlOT1M1X0JVU19ERVZGUkVRKQkrPSBleHlub3MvCitvYmotJChDT05GSUdfQVJNX1RFR1JBX0RFVkZSRVEpCQkrPSB0ZWdyYS1kZXZmcmVxLm8KKworIyBERVZGUkVRIEV2ZW50IERyaXZlcnMKK29iai0kKENPTkZJR19QTV9ERVZGUkVRX0VWRU5UKQkJKz0gZXZlbnQvCmRpZmYgLS1naXQgYS9kcml2ZXJzL2RldmZyZXEvZGV2ZnJlcS1ldmVudC5jIGIvZHJpdmVycy9kZXZmcmVxL2RldmZyZXEtZXZlbnQuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5mMzA0YTAyCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9kZXZmcmVxL2RldmZyZXEtZXZlbnQuYwpAQCAtMCwwICsxLDQ5NCBAQAorLyoKKyAqIGRldmZyZXEtZXZlbnQ6IGEgZnJhbWV3b3JrIHRvIHByb3ZpZGUgcmF3IGRhdGEgYW5kIGV2ZW50cyBvZiBkZXZmcmVxIGRldmljZXMKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMTUgU2Ftc3VuZyBFbGVjdHJvbmljcworICogQXV0aG9yOiBDaGFud29vIENob2kgPGN3MDAuY2hvaUBzYW1zdW5nLmNvbT4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorICoKKyAqIFRoaXMgZHJpdmVyIGlzIGJhc2VkIG9uIGRyaXZlcnMvZGV2ZnJlcS9kZXZmcmVxLmMuCisgKi8KKworI2luY2x1ZGUgPGxpbnV4L2RldmZyZXEtZXZlbnQuaD4KKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9lcnIuaD4KKyNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvc2xhYi5oPgorI2luY2x1ZGUgPGxpbnV4L2xpc3QuaD4KKyNpbmNsdWRlIDxsaW51eC9vZi5oPgorCitzdGF0aWMgc3RydWN0IGNsYXNzICpkZXZmcmVxX2V2ZW50X2NsYXNzOworCisvKiBUaGUgbGlzdCBvZiBhbGwgZGV2ZnJlcSBldmVudCBsaXN0ICovCitzdGF0aWMgTElTVF9IRUFEKGRldmZyZXFfZXZlbnRfbGlzdCk7CitzdGF0aWMgREVGSU5FX01VVEVYKGRldmZyZXFfZXZlbnRfbGlzdF9sb2NrKTsKKworI2RlZmluZSB0b19kZXZmcmVxX2V2ZW50KERFVikgY29udGFpbmVyX29mKERFViwgc3RydWN0IGRldmZyZXFfZXZlbnRfZGV2LCBkZXYpCisKKy8qKgorICogZGV2ZnJlcV9ldmVudF9lbmFibGVfZWRldigpIC0gRW5hYmxlIHRoZSBkZXZmcmVxLWV2ZW50IGRldiBhbmQgaW5jcmVhc2UKKyAqCQkJCSB0aGUgZW5hYmxlX2NvdW50IG9mIGRldmZyZXEtZXZlbnQgZGV2LgorICogQGVkZXYJOiB0aGUgZGV2ZnJlcS1ldmVudCBkZXZpY2UKKyAqCisgKiBOb3RlIHRoYXQgdGhpcyBmdW5jdGlvbiBpbmNyZWFzZSB0aGUgZW5hYmxlX2NvdW50IGFuZCBlbmFibGUgdGhlCisgKiBkZXZmcmVxLWV2ZW50IGRldmljZS4gVGhlIGRldmZyZXEtZXZlbnQgZGV2aWNlIHNob3VsZCBiZSBlbmFibGVkIGJlZm9yZQorICogdXNpbmcgaXQgYnkgZGV2ZnJlcSBkZXZpY2UuCisgKi8KK2ludCBkZXZmcmVxX2V2ZW50X2VuYWJsZV9lZGV2KHN0cnVjdCBkZXZmcmVxX2V2ZW50X2RldiAqZWRldikKK3sKKwlpbnQgcmV0ID0gMDsKKworCWlmICghZWRldiB8fCAhZWRldi0+ZGVzYykKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwltdXRleF9sb2NrKCZlZGV2LT5sb2NrKTsKKwlpZiAoZWRldi0+ZGVzYy0+b3BzICYmIGVkZXYtPmRlc2MtPm9wcy0+ZW5hYmxlCisJCQkmJiBlZGV2LT5lbmFibGVfY291bnQgPT0gMCkgeworCQlyZXQgPSBlZGV2LT5kZXNjLT5vcHMtPmVuYWJsZShlZGV2KTsKKwkJaWYgKHJldCA8IDApCisJCQlnb3RvIGVycjsKKwl9CisJZWRldi0+ZW5hYmxlX2NvdW50Kys7CitlcnI6CisJbXV0ZXhfdW5sb2NrKCZlZGV2LT5sb2NrKTsKKworCXJldHVybiByZXQ7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChkZXZmcmVxX2V2ZW50X2VuYWJsZV9lZGV2KTsKKworLyoqCisgKiBkZXZmcmVxX2V2ZW50X2Rpc2FibGVfZWRldigpIC0gRGlzYWJsZSB0aGUgZGV2ZnJlcS1ldmVudCBkZXYgYW5kIGRlY3JlYXNlCisgKgkJCQkgIHRoZSBlbmFibGVfY291bnQgb2YgdGhlIGRldmZyZXEtZXZlbnQgZGV2LgorICogQGVkZXYJOiB0aGUgZGV2ZnJlcS1ldmVudCBkZXZpY2UKKyAqCisgKiBOb3RlIHRoYXQgdGhpcyBmdW5jdGlvbiBkZWNyZWFzZSB0aGUgZW5hYmxlX2NvdW50IGFuZCBkaXNhYmxlIHRoZQorICogZGV2ZnJlcS1ldmVudCBkZXZpY2UuIEFmdGVyIHRoZSBkZXZmcmVxLWV2ZW50IGRldmljZSBpcyBkaXNhYmxlZCwKKyAqIGRldmZyZXEgZGV2aWNlIGNhbid0IHVzZSB0aGUgZGV2ZnJlcS1ldmVudCBkZXZpY2UgZm9yIGdldC9zZXQvcmVzZXQKKyAqIG9wZXJhdGlvbnMuCisgKi8KK2ludCBkZXZmcmVxX2V2ZW50X2Rpc2FibGVfZWRldihzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kZXYgKmVkZXYpCit7CisJaW50IHJldCA9IDA7CisKKwlpZiAoIWVkZXYgfHwgIWVkZXYtPmRlc2MpCisJCXJldHVybiAtRUlOVkFMOworCisJbXV0ZXhfbG9jaygmZWRldi0+bG9jayk7CisJaWYgKGVkZXYtPmVuYWJsZV9jb3VudCA8PSAwKSB7CisJCWRldl93YXJuKCZlZGV2LT5kZXYsICJ1bmJhbGFuY2VkIGVuYWJsZV9jb3VudFxuIik7CisJCXJldCA9IC1FSU87CisJCWdvdG8gZXJyOworCX0KKworCWlmIChlZGV2LT5kZXNjLT5vcHMgJiYgZWRldi0+ZGVzYy0+b3BzLT5kaXNhYmxlCisJCQkmJiBlZGV2LT5lbmFibGVfY291bnQgPT0gMSkgeworCQlyZXQgPSBlZGV2LT5kZXNjLT5vcHMtPmRpc2FibGUoZWRldik7CisJCWlmIChyZXQgPCAwKQorCQkJZ290byBlcnI7CisJfQorCWVkZXYtPmVuYWJsZV9jb3VudC0tOworZXJyOgorCW11dGV4X3VubG9jaygmZWRldi0+bG9jayk7CisKKwlyZXR1cm4gcmV0OworfQorRVhQT1JUX1NZTUJPTF9HUEwoZGV2ZnJlcV9ldmVudF9kaXNhYmxlX2VkZXYpOworCisvKioKKyAqIGRldmZyZXFfZXZlbnRfaXNfZW5hYmxlZCgpIC0gQ2hlY2sgd2hldGhlciBkZXZmcmVxLWV2ZW50IGRldiBpcyBlbmFibGVkIG9yCisgKgkJCQlub3QuCisgKiBAZWRldgk6IHRoZSBkZXZmcmVxLWV2ZW50IGRldmljZQorICoKKyAqIE5vdGUgdGhhdCB0aGlzIGZ1bmN0aW9uIGNoZWNrIHdoZXRoZXIgZGV2ZnJlcS1ldmVudCBkZXYgaXMgZW5hYmxlZCBvciBub3QuCisgKiBJZiByZXR1cm4gdHJ1ZSwgdGhlIGRldmZyZXEtZXZlbnQgZGV2IGlzIGVuYWJlbGQuIElmIHJldHVybiBmYWxzZSwgdGhlCisgKiBkZXZmcmVxLWV2ZW50IGRldiBpcyBkaXNhYmxlZC4KKyAqLworYm9vbCBkZXZmcmVxX2V2ZW50X2lzX2VuYWJsZWQoc3RydWN0IGRldmZyZXFfZXZlbnRfZGV2ICplZGV2KQoreworCWJvb2wgZW5hYmxlZCA9IGZhbHNlOworCisJaWYgKCFlZGV2IHx8ICFlZGV2LT5kZXNjKQorCQlyZXR1cm4gZW5hYmxlZDsKKworCW11dGV4X2xvY2soJmVkZXYtPmxvY2spOworCisJaWYgKGVkZXYtPmVuYWJsZV9jb3VudCA+IDApCisJCWVuYWJsZWQgPSB0cnVlOworCisJbXV0ZXhfdW5sb2NrKCZlZGV2LT5sb2NrKTsKKworCXJldHVybiBlbmFibGVkOworfQorRVhQT1JUX1NZTUJPTF9HUEwoZGV2ZnJlcV9ldmVudF9pc19lbmFibGVkKTsKKworLyoqCisgKiBkZXZmcmVxX2V2ZW50X3NldF9ldmVudCgpIC0gU2V0IGV2ZW50IHRvIGRldmZyZXEtZXZlbnQgZGV2IHRvIHN0YXJ0LgorICogQGVkZXYJOiB0aGUgZGV2ZnJlcS1ldmVudCBkZXZpY2UKKyAqCisgKiBOb3RlIHRoYXQgdGhpcyBmdW5jdGlvbiBzZXQgdGhlIGV2ZW50IHRvIHRoZSBkZXZmcmVxLWV2ZW50IGRldmljZSB0byBzdGFydAorICogZm9yIGdldHRpbmcgdGhlIGV2ZW50IGRhdGEgd2hpY2ggY291bGQgYmUgdmFyaW91cyBldmVudCB0eXBlLgorICovCitpbnQgZGV2ZnJlcV9ldmVudF9zZXRfZXZlbnQoc3RydWN0IGRldmZyZXFfZXZlbnRfZGV2ICplZGV2KQoreworCWludCByZXQ7CisKKwlpZiAoIWVkZXYgfHwgIWVkZXYtPmRlc2MpCisJCXJldHVybiAtRUlOVkFMOworCisJaWYgKCFlZGV2LT5kZXNjLT5vcHMgfHwgIWVkZXYtPmRlc2MtPm9wcy0+c2V0X2V2ZW50KQorCQlyZXR1cm4gLUVJTlZBTDsKKworCWlmICghZGV2ZnJlcV9ldmVudF9pc19lbmFibGVkKGVkZXYpKQorCQlyZXR1cm4gLUVQRVJNOworCisJbXV0ZXhfbG9jaygmZWRldi0+bG9jayk7CisJcmV0ID0gZWRldi0+ZGVzYy0+b3BzLT5zZXRfZXZlbnQoZWRldik7CisJbXV0ZXhfdW5sb2NrKCZlZGV2LT5sb2NrKTsKKworCXJldHVybiByZXQ7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChkZXZmcmVxX2V2ZW50X3NldF9ldmVudCk7CisKKy8qKgorICogZGV2ZnJlcV9ldmVudF9nZXRfZXZlbnQoKSAtIEdldCB7bG9hZHx0b3RhbH1fY291bnQgZnJvbSBkZXZmcmVxLWV2ZW50IGRldi4KKyAqIEBlZGV2CTogdGhlIGRldmZyZXEtZXZlbnQgZGV2aWNlCisgKiBAZWRhdGEJOiB0aGUgY2FsY3VsYXRlZCBkYXRhIG9mIGRldmZyZXEtZXZlbnQgZGV2aWNlCisgKgorICogTm90ZSB0aGF0IHRoaXMgZnVuY3Rpb24gZ2V0IHRoZSBjYWxjdWxhdGVkIGV2ZW50IGRhdGEgZnJvbSBkZXZmcmVxLWV2ZW50IGRldgorICogYWZ0ZXIgc3RvcGluZyB0aGUgcHJvZ3Jlc3Mgb2Ygd2hvbGUgc2VxdWVuY2Ugb2YgZGV2ZnJlcS1ldmVudCBkZXYuCisgKi8KK2ludCBkZXZmcmVxX2V2ZW50X2dldF9ldmVudChzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kZXYgKmVkZXYsCisJCQkgICAgc3RydWN0IGRldmZyZXFfZXZlbnRfZGF0YSAqZWRhdGEpCit7CisJaW50IHJldDsKKworCWlmICghZWRldiB8fCAhZWRldi0+ZGVzYykKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlpZiAoIWVkZXYtPmRlc2MtPm9wcyB8fCAhZWRldi0+ZGVzYy0+b3BzLT5nZXRfZXZlbnQpCisJCXJldHVybiAtRUlOVkFMOworCisJaWYgKCFkZXZmcmVxX2V2ZW50X2lzX2VuYWJsZWQoZWRldikpCisJCXJldHVybiAtRUlOVkFMOworCisJZWRhdGEtPnRvdGFsX2NvdW50ID0gZWRhdGEtPmxvYWRfY291bnQgPSAwOworCisJbXV0ZXhfbG9jaygmZWRldi0+bG9jayk7CisJcmV0ID0gZWRldi0+ZGVzYy0+b3BzLT5nZXRfZXZlbnQoZWRldiwgZWRhdGEpOworCWlmIChyZXQgPCAwKQorCQllZGF0YS0+dG90YWxfY291bnQgPSBlZGF0YS0+bG9hZF9jb3VudCA9IDA7CisJbXV0ZXhfdW5sb2NrKCZlZGV2LT5sb2NrKTsKKworCXJldHVybiByZXQ7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChkZXZmcmVxX2V2ZW50X2dldF9ldmVudCk7CisKKy8qKgorICogZGV2ZnJlcV9ldmVudF9yZXNldF9ldmVudCgpIC0gUmVzZXQgYWxsIG9wZWF0aW9ucyBvZiBkZXZmcmVxLWV2ZW50IGRldi4KKyAqIEBlZGV2CTogdGhlIGRldmZyZXEtZXZlbnQgZGV2aWNlCisgKgorICogTm90ZSB0aGF0IHRoaXMgZnVuY3Rpb24gc3RvcCBhbGwgb3BlcmF0aW9ucyBvZiBkZXZmcmVxLWV2ZW50IGRldiBhbmQgcmVzZXQKKyAqIHRoZSBjdXJyZW50IGV2ZW50IGRhdGEgdG8gbWFrZSB0aGUgZGV2ZnJlcS1ldmVudCBkZXZpY2UgaW50byBpbml0aWFsIHN0YXRlLgorICovCitpbnQgZGV2ZnJlcV9ldmVudF9yZXNldF9ldmVudChzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kZXYgKmVkZXYpCit7CisJaW50IHJldCA9IDA7CisKKwlpZiAoIWVkZXYgfHwgIWVkZXYtPmRlc2MpCisJCXJldHVybiAtRUlOVkFMOworCisJaWYgKCFkZXZmcmVxX2V2ZW50X2lzX2VuYWJsZWQoZWRldikpCisJCXJldHVybiAtRVBFUk07CisKKwltdXRleF9sb2NrKCZlZGV2LT5sb2NrKTsKKwlpZiAoZWRldi0+ZGVzYy0+b3BzICYmIGVkZXYtPmRlc2MtPm9wcy0+cmVzZXQpCisJCXJldCA9IGVkZXYtPmRlc2MtPm9wcy0+cmVzZXQoZWRldik7CisJbXV0ZXhfdW5sb2NrKCZlZGV2LT5sb2NrKTsKKworCXJldHVybiByZXQ7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChkZXZmcmVxX2V2ZW50X3Jlc2V0X2V2ZW50KTsKKworLyoqCisgKiBkZXZmcmVxX2V2ZW50X2dldF9lZGV2X2J5X3BoYW5kbGUoKSAtIEdldCB0aGUgZGV2ZnJlcS1ldmVudCBkZXYgZnJvbQorICoJCQkJCSBkZXZpY2V0cmVlLgorICogQGRldgkJOiB0aGUgcG9pbnRlciB0byB0aGUgZ2l2ZW4gZGV2aWNlCisgKiBAaW5kZXgJOiB0aGUgaW5kZXggaW50byBsaXN0IG9mIGRldmZyZXEtZXZlbnQgZGV2aWNlCisgKgorICogTm90ZSB0aGF0IHRoaXMgZnVuY3Rpb24gcmV0dXJuIHRoZSBwb2ludGVyIG9mIGRldmZyZXEtZXZlbnQgZGV2aWNlLgorICovCitzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kZXYgKmRldmZyZXFfZXZlbnRfZ2V0X2VkZXZfYnlfcGhhbmRsZShzdHJ1Y3QgZGV2aWNlICpkZXYsCisJCQkJCQkgICAgICBpbnQgaW5kZXgpCit7CisJc3RydWN0IGRldmljZV9ub2RlICpub2RlOworCXN0cnVjdCBkZXZmcmVxX2V2ZW50X2RldiAqZWRldjsKKworCWlmICghZGV2LT5vZl9ub2RlKSB7CisJCWRldl9lcnIoZGV2LCAiZGV2aWNlIGRvZXMgbm90IGhhdmUgYSBkZXZpY2Ugbm9kZSBlbnRyeVxuIik7CisJCXJldHVybiBFUlJfUFRSKC1FSU5WQUwpOworCX0KKworCW5vZGUgPSBvZl9wYXJzZV9waGFuZGxlKGRldi0+b2Zfbm9kZSwgImRldmZyZXEtZXZlbnRzIiwgaW5kZXgpOworCWlmICghbm9kZSkgeworCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0byBnZXQgcGhhbmRsZSBpbiAlcyBub2RlXG4iLAorCQkJZGV2LT5vZl9ub2RlLT5mdWxsX25hbWUpOworCQlyZXR1cm4gRVJSX1BUUigtRU5PREVWKTsKKwl9CisKKwltdXRleF9sb2NrKCZkZXZmcmVxX2V2ZW50X2xpc3RfbG9jayk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeShlZGV2LCAmZGV2ZnJlcV9ldmVudF9saXN0LCBub2RlKSB7CisJCWlmICghc3RyY21wKGVkZXYtPmRlc2MtPm5hbWUsIG5vZGUtPm5hbWUpKQorCQkJZ290byBvdXQ7CisJfQorCWVkZXYgPSBOVUxMOworb3V0OgorCW11dGV4X3VubG9jaygmZGV2ZnJlcV9ldmVudF9saXN0X2xvY2spOworCisJaWYgKCFlZGV2KSB7CisJCWRldl9lcnIoZGV2LCAidW5hYmxlIHRvIGdldCBkZXZmcmVxLWV2ZW50IGRldmljZSA6ICVzXG4iLAorCQkJbm9kZS0+bmFtZSk7CisJCW9mX25vZGVfcHV0KG5vZGUpOworCQlyZXR1cm4gRVJSX1BUUigtRU5PREVWKTsKKwl9CisKKwlvZl9ub2RlX3B1dChub2RlKTsKKworCXJldHVybiBlZGV2OworfQorRVhQT1JUX1NZTUJPTF9HUEwoZGV2ZnJlcV9ldmVudF9nZXRfZWRldl9ieV9waGFuZGxlKTsKKworLyoqCisgKiBkZXZmcmVxX2V2ZW50X2dldF9lZGV2X2NvdW50KCkgLSBHZXQgdGhlIGNvdW50IG9mIGRldmZyZXEtZXZlbnQgZGV2CisgKiBAZGV2CQk6IHRoZSBwb2ludGVyIHRvIHRoZSBnaXZlbiBkZXZpY2UKKyAqCisgKiBOb3RlIHRoYXQgdGhpcyBmdW5jdGlvbiByZXR1cm4gdGhlIGNvdW50IG9mIGRldmZyZXEtZXZlbnQgZGV2aWNlcy4KKyAqLworaW50IGRldmZyZXFfZXZlbnRfZ2V0X2VkZXZfY291bnQoc3RydWN0IGRldmljZSAqZGV2KQoreworCWludCBjb3VudDsKKworCWlmICghZGV2LT5vZl9ub2RlKSB7CisJCWRldl9lcnIoZGV2LCAiZGV2aWNlIGRvZXMgbm90IGhhdmUgYSBkZXZpY2Ugbm9kZSBlbnRyeVxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCWNvdW50ID0gb2ZfcHJvcGVydHlfY291bnRfZWxlbXNfb2Zfc2l6ZShkZXYtPm9mX25vZGUsICJkZXZmcmVxLWV2ZW50cyIsCisJCQkJCQlzaXplb2YodTMyKSk7CisJaWYgKGNvdW50IDwgMCApIHsKKwkJZGV2X2VycihkZXYsCisJCQkiZmFpbGVkIHRvIGdldCB0aGUgY291bnQgb2YgZGV2ZnJlcS1ldmVudCBpbiAlcyBub2RlXG4iLAorCQkJZGV2LT5vZl9ub2RlLT5mdWxsX25hbWUpOworCQlyZXR1cm4gY291bnQ7CisJfQorCisJcmV0dXJuIGNvdW50OworfQorRVhQT1JUX1NZTUJPTF9HUEwoZGV2ZnJlcV9ldmVudF9nZXRfZWRldl9jb3VudCk7CisKK3N0YXRpYyB2b2lkIGRldmZyZXFfZXZlbnRfcmVsZWFzZV9lZGV2KHN0cnVjdCBkZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kZXYgKmVkZXYgPSB0b19kZXZmcmVxX2V2ZW50KGRldik7CisKKwlrZnJlZShlZGV2KTsKK30KKworLyoqCisgKiBkZXZmcmVxX2V2ZW50X2FkZF9lZGV2KCkgLSBBZGQgbmV3IGRldmZyZXEtZXZlbnQgZGV2aWNlLgorICogQGRldgkJOiB0aGUgZGV2aWNlIG93bmluZyB0aGUgZGV2ZnJlcS1ldmVudCBkZXZpY2UgYmVpbmcgY3JlYXRlZAorICogQGRlc2MJOiB0aGUgZGV2ZnJlcS1ldmVudCBkZXZpY2UncyBkZWNyaXB0b3Igd2hpY2ggaW5jbHVkZSBlc3NlbnRpYWwKKyAqCQkgIGRhdGEgZm9yIGRldmZyZXEtZXZlbnQgZGV2aWNlLgorICoKKyAqIE5vdGUgdGhhdCB0aGlzIGZ1bmN0aW9uIGFkZCBuZXcgZGV2ZnJlcS1ldmVudCBkZXZpY2UgdG8gZGV2ZnJlcS1ldmVudCBjbGFzcworICogbGlzdCBhbmQgcmVnaXN0ZXIgdGhlIGRldmljZSBvZiB0aGUgZGV2ZnJlcS1ldmVudCBkZXZpY2UuCisgKi8KK3N0cnVjdCBkZXZmcmVxX2V2ZW50X2RldiAqZGV2ZnJlcV9ldmVudF9hZGRfZWRldihzdHJ1Y3QgZGV2aWNlICpkZXYsCisJCQkJCQlzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kZXNjICpkZXNjKQoreworCXN0cnVjdCBkZXZmcmVxX2V2ZW50X2RldiAqZWRldjsKKwlzdGF0aWMgYXRvbWljX3QgZXZlbnRfbm8gPSBBVE9NSUNfSU5JVCgwKTsKKwlpbnQgcmV0OworCisJaWYgKCFkZXYgfHwgIWRlc2MpCisJCXJldHVybiBFUlJfUFRSKC1FSU5WQUwpOworCisJaWYgKCFkZXNjLT5uYW1lIHx8ICFkZXNjLT5vcHMpCisJCXJldHVybiBFUlJfUFRSKC1FSU5WQUwpOworCisJaWYgKCFkZXNjLT5vcHMtPnNldF9ldmVudCB8fCAhZGVzYy0+b3BzLT5nZXRfZXZlbnQpCisJCXJldHVybiBFUlJfUFRSKC1FSU5WQUwpOworCisJZWRldiA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBkZXZmcmVxX2V2ZW50X2RldiksIEdGUF9LRVJORUwpOworCWlmICghZWRldikKKwkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7CisKKwltdXRleF9pbml0KCZlZGV2LT5sb2NrKTsKKwllZGV2LT5kZXNjID0gZGVzYzsKKwllZGV2LT5lbmFibGVfY291bnQgPSAwOworCWVkZXYtPmRldi5wYXJlbnQgPSBkZXY7CisJZWRldi0+ZGV2LmNsYXNzID0gZGV2ZnJlcV9ldmVudF9jbGFzczsKKwllZGV2LT5kZXYucmVsZWFzZSA9IGRldmZyZXFfZXZlbnRfcmVsZWFzZV9lZGV2OworCisJZGV2X3NldF9uYW1lKCZlZGV2LT5kZXYsICJldmVudC4lZCIsIGF0b21pY19pbmNfcmV0dXJuKCZldmVudF9ubykgLSAxKTsKKwlyZXQgPSBkZXZpY2VfcmVnaXN0ZXIoJmVkZXYtPmRldik7CisJaWYgKHJldCA8IDApIHsKKwkJcHV0X2RldmljZSgmZWRldi0+ZGV2KTsKKwkJcmV0dXJuIEVSUl9QVFIocmV0KTsKKwl9CisJZGV2X3NldF9kcnZkYXRhKCZlZGV2LT5kZXYsIGVkZXYpOworCisJSU5JVF9MSVNUX0hFQUQoJmVkZXYtPm5vZGUpOworCisJbXV0ZXhfbG9jaygmZGV2ZnJlcV9ldmVudF9saXN0X2xvY2spOworCWxpc3RfYWRkKCZlZGV2LT5ub2RlLCAmZGV2ZnJlcV9ldmVudF9saXN0KTsKKwltdXRleF91bmxvY2soJmRldmZyZXFfZXZlbnRfbGlzdF9sb2NrKTsKKworCXJldHVybiBlZGV2OworfQorRVhQT1JUX1NZTUJPTF9HUEwoZGV2ZnJlcV9ldmVudF9hZGRfZWRldik7CisKKy8qKgorICogZGV2ZnJlcV9ldmVudF9yZW1vdmVfZWRldigpIC0gUmVtb3ZlIHRoZSBkZXZmcmVxLWV2ZW50IGRldmljZSByZWdpc3RlcmVkLgorICogQGRldgkJOiB0aGUgZGV2ZnJlcS1ldmVudCBkZXZpY2UKKyAqCisgKiBOb3RlIHRoYXQgdGhpcyBmdW5jdGlvbiByZW1vdmUgdGhlIHJlZ2lzdGVyZWQgZGV2ZnJlcS1ldmVudCBkZXZpY2UuCisgKi8KK2ludCBkZXZmcmVxX2V2ZW50X3JlbW92ZV9lZGV2KHN0cnVjdCBkZXZmcmVxX2V2ZW50X2RldiAqZWRldikKK3sKKwlpZiAoIWVkZXYpCisJCXJldHVybiAtRUlOVkFMOworCisJV0FSTl9PTihlZGV2LT5lbmFibGVfY291bnQpOworCisJbXV0ZXhfbG9jaygmZGV2ZnJlcV9ldmVudF9saXN0X2xvY2spOworCWxpc3RfZGVsKCZlZGV2LT5ub2RlKTsKKwltdXRleF91bmxvY2soJmRldmZyZXFfZXZlbnRfbGlzdF9sb2NrKTsKKworCWRldmljZV91bnJlZ2lzdGVyKCZlZGV2LT5kZXYpOworCisJcmV0dXJuIDA7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChkZXZmcmVxX2V2ZW50X3JlbW92ZV9lZGV2KTsKKworc3RhdGljIGludCBkZXZtX2RldmZyZXFfZXZlbnRfbWF0Y2goc3RydWN0IGRldmljZSAqZGV2LCB2b2lkICpyZXMsIHZvaWQgKmRhdGEpCit7CisJc3RydWN0IGRldmZyZXFfZXZlbnRfZGV2ICoqciA9IHJlczsKKworCWlmIChXQVJOX09OKCFyIHx8ICEqcikpCisJCXJldHVybiAwOworCisJcmV0dXJuICpyID09IGRhdGE7Cit9CisKK3N0YXRpYyB2b2lkIGRldm1fZGV2ZnJlcV9ldmVudF9yZWxlYXNlKHN0cnVjdCBkZXZpY2UgKmRldiwgdm9pZCAqcmVzKQoreworCWRldmZyZXFfZXZlbnRfcmVtb3ZlX2VkZXYoKihzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kZXYgKiopcmVzKTsKK30KKworLyoqCisgKiBkZXZtX2RldmZyZXFfZXZlbnRfYWRkX2VkZXYoKSAtIFJlc291cmNlLW1hbmFnZWQgZGV2ZnJlcV9ldmVudF9hZGRfZWRldigpCisgKiBAZGV2CQk6IHRoZSBkZXZpY2Ugb3duaW5nIHRoZSBkZXZmcmVxLWV2ZW50IGRldmljZSBiZWluZyBjcmVhdGVkCisgKiBAZGVzYwk6IHRoZSBkZXZmcmVxLWV2ZW50IGRldmljZSdzIGRlY3JpcHRvciB3aGljaCBpbmNsdWRlIGVzc2VudGlhbAorICoJCSAgZGF0YSBmb3IgZGV2ZnJlcS1ldmVudCBkZXZpY2UuCisgKgorICogTm90ZSB0aGF0IHRoaXMgZnVuY3Rpb24gbWFuYWdlcyBhdXRvbWF0aWNhbGx5IHRoZSBtZW1vcnkgb2YgZGV2ZnJlcS1ldmVudAorICogZGV2aWNlIHVzaW5nIGRldmljZSByZXNvdXJjZSBtYW5hZ2VtZW50IGFuZCBzaW1wbGlmeSB0aGUgZnJlZSBvcGVyYXRpb24KKyAqIGZvciBtZW1vcnkgb2YgZGV2ZnJlcS1ldmVudCBkZXZpY2UuCisgKi8KK3N0cnVjdCBkZXZmcmVxX2V2ZW50X2RldiAqZGV2bV9kZXZmcmVxX2V2ZW50X2FkZF9lZGV2KHN0cnVjdCBkZXZpY2UgKmRldiwKKwkJCQkJCXN0cnVjdCBkZXZmcmVxX2V2ZW50X2Rlc2MgKmRlc2MpCit7CisJc3RydWN0IGRldmZyZXFfZXZlbnRfZGV2ICoqcHRyLCAqZWRldjsKKworCXB0ciA9IGRldnJlc19hbGxvYyhkZXZtX2RldmZyZXFfZXZlbnRfcmVsZWFzZSwgc2l6ZW9mKCpwdHIpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIXB0cikKKwkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7CisKKwllZGV2ID0gZGV2ZnJlcV9ldmVudF9hZGRfZWRldihkZXYsIGRlc2MpOworCWlmIChJU19FUlIoZWRldikpIHsKKwkJZGV2cmVzX2ZyZWUocHRyKTsKKwkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7CisJfQorCisJKnB0ciA9IGVkZXY7CisJZGV2cmVzX2FkZChkZXYsIHB0cik7CisKKwlyZXR1cm4gZWRldjsKK30KK0VYUE9SVF9TWU1CT0xfR1BMKGRldm1fZGV2ZnJlcV9ldmVudF9hZGRfZWRldik7CisKKy8qKgorICogZGV2bV9kZXZmcmVxX2V2ZW50X3JlbW92ZV9lZGV2KCktIFJlc291cmNlLW1hbmFnZWQgZGV2ZnJlcV9ldmVudF9yZW1vdmVfZWRldigpCisgKiBAZGV2CQk6IHRoZSBkZXZpY2Ugb3duaW5nIHRoZSBkZXZmcmVxLWV2ZW50IGRldmljZSBiZWluZyBjcmVhdGVkCisgKiBAZWRldgk6IHRoZSBkZXZmcmVxLWV2ZW50IGRldmljZQorICoKKyAqIE5vdGUgdGhhdCB0aGlzIGZ1bmN0aW9uIG1hbmFnZXMgYXV0b21hdGljYWxseSB0aGUgbWVtb3J5IG9mIGRldmZyZXEtZXZlbnQKKyAqIGRldmljZSB1c2luZyBkZXZpY2UgcmVzb3VyY2UgbWFuYWdlbWVudC4KKyAqLwordm9pZCBkZXZtX2RldmZyZXFfZXZlbnRfcmVtb3ZlX2VkZXYoc3RydWN0IGRldmljZSAqZGV2LAorCQkJCXN0cnVjdCBkZXZmcmVxX2V2ZW50X2RldiAqZWRldikKK3sKKwlXQVJOX09OKGRldnJlc19yZWxlYXNlKGRldiwgZGV2bV9kZXZmcmVxX2V2ZW50X3JlbGVhc2UsCisJCQkgICAgICAgZGV2bV9kZXZmcmVxX2V2ZW50X21hdGNoLCBlZGV2KSk7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChkZXZtX2RldmZyZXFfZXZlbnRfcmVtb3ZlX2VkZXYpOworCisvKgorICogRGV2aWNlIGF0dHJpYnV0ZXMgZm9yIGRldmZyZXEtZXZlbnQgY2xhc3MuCisgKi8KK3N0YXRpYyBzc2l6ZV90IG5hbWVfc2hvdyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAorCQkJIGNoYXIgKmJ1ZikKK3sKKwlzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kZXYgKmVkZXYgPSB0b19kZXZmcmVxX2V2ZW50KGRldik7CisKKwlpZiAoIWVkZXYgfHwgIWVkZXYtPmRlc2MpCisJCXJldHVybiAtRUlOVkFMOworCisJcmV0dXJuIHNwcmludGYoYnVmLCAiJXNcbiIsIGVkZXYtPmRlc2MtPm5hbWUpOworfQorc3RhdGljIERFVklDRV9BVFRSX1JPKG5hbWUpOworCitzdGF0aWMgc3NpemVfdCBlbmFibGVfY291bnRfc2hvdyhzdHJ1Y3QgZGV2aWNlICpkZXYsCisJCQkJICBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwgY2hhciAqYnVmKQoreworCXN0cnVjdCBkZXZmcmVxX2V2ZW50X2RldiAqZWRldiA9IHRvX2RldmZyZXFfZXZlbnQoZGV2KTsKKworCWlmICghZWRldiB8fCAhZWRldi0+ZGVzYykKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlyZXR1cm4gc3ByaW50ZihidWYsICIlZFxuIiwgZWRldi0+ZW5hYmxlX2NvdW50KTsKK30KK3N0YXRpYyBERVZJQ0VfQVRUUl9STyhlbmFibGVfY291bnQpOworCitzdGF0aWMgc3RydWN0IGF0dHJpYnV0ZSAqZGV2ZnJlcV9ldmVudF9hdHRyc1tdID0geworCSZkZXZfYXR0cl9uYW1lLmF0dHIsCisJJmRldl9hdHRyX2VuYWJsZV9jb3VudC5hdHRyLAorCU5VTEwsCit9OworQVRUUklCVVRFX0dST1VQUyhkZXZmcmVxX2V2ZW50KTsKKworc3RhdGljIGludCBfX2luaXQgZGV2ZnJlcV9ldmVudF9pbml0KHZvaWQpCit7CisJZGV2ZnJlcV9ldmVudF9jbGFzcyA9IGNsYXNzX2NyZWF0ZShUSElTX01PRFVMRSwgImRldmZyZXEtZXZlbnQiKTsKKwlpZiAoSVNfRVJSKGRldmZyZXFfZXZlbnRfY2xhc3MpKSB7CisJCXByX2VycigiJXM6IGNvdWxkbid0IGNyZWF0ZSBjbGFzc1xuIiwgX19GSUxFX18pOworCQlyZXR1cm4gUFRSX0VSUihkZXZmcmVxX2V2ZW50X2NsYXNzKTsKKwl9CisKKwlkZXZmcmVxX2V2ZW50X2NsYXNzLT5kZXZfZ3JvdXBzID0gZGV2ZnJlcV9ldmVudF9ncm91cHM7CisKKwlyZXR1cm4gMDsKK30KK3N1YnN5c19pbml0Y2FsbChkZXZmcmVxX2V2ZW50X2luaXQpOworCitzdGF0aWMgdm9pZCBfX2V4aXQgZGV2ZnJlcV9ldmVudF9leGl0KHZvaWQpCit7CisJY2xhc3NfZGVzdHJveShkZXZmcmVxX2V2ZW50X2NsYXNzKTsKK30KK21vZHVsZV9leGl0KGRldmZyZXFfZXZlbnRfZXhpdCk7CisKK01PRFVMRV9BVVRIT1IoIkNoYW53b28gQ2hvaSA8Y3cwMC5jaG9pQHNhbXN1bmcuY29tPiIpOworTU9EVUxFX0RFU0NSSVBUSU9OKCJERVZGUkVRLUV2ZW50IGNsYXNzIHN1cHBvcnQiKTsKK01PRFVMRV9MSUNFTlNFKCJHUEwiKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZGV2ZnJlcS9ldmVudC9LY29uZmlnIGIvZHJpdmVycy9kZXZmcmVxL2V2ZW50L0tjb25maWcKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYTExNzIwYQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZGV2ZnJlcS9ldmVudC9LY29uZmlnCkBAIC0wLDAgKzEsMjUgQEAKK21lbnVjb25maWcgUE1fREVWRlJFUV9FVkVOVAorCWJvb2wgIkRFVkZSRVEtRXZlbnQgZGV2aWNlIFN1cHBvcnQiCisJaGVscAorCSAgVGhlIGRldmZyZXEtZXZlbnQgZGV2aWNlIHByb3ZpZGUgdGhlIHJhdyBkYXRhIGFuZCBldmVudHMgd2hpY2gKKwkgIGluZGljYXRlIHRoZSBjdXJyZW50IHN0YXRlIG9mIGRldmZyZXEtZXZlbnQgZGV2aWNlLiBUaGUgcHJvdmlkZWQKKwkgIGRhdGEgZnJvbSBkZXZmcmVxLWV2ZW50IGRldmljZSBpcyB1c2VkIHRvIG1vbml0b3IgdGhlIHN0YXRlIG9mCisJICBkZXZpY2UgYW5kIGRldGVybWluZSB0aGUgc3VpdGFibGUgc2l6ZSBvZiByZXNvdXJjZSB0byByZWR1Y2UgdGhlCisJICB3YXN0ZWQgcmVzb3VyY2UuCisKKwkgIFRoZSBkZXZmcmVxLWV2ZW50IGRldmljZSBjYW4gc3VwcG9ydCB0aGUgdmFyaW91cyB0eXBlIG9mIGV2ZW50cworCSAgKGUuZy4sIHJhdyBkYXRhLCB1dGlsaXphdGlvbiwgbGF0ZW5jeSwgYmFuZHdpZHRoKS4gVGhlIGV2ZW50cworCSAgbWF5IGJlIHVzZWQgYnkgZGV2ZnJlcSBnb3Zlcm5vciBhbmQgb3RoZXIgc3Vic3lzdGVtLgorCitpZiBQTV9ERVZGUkVRX0VWRU5UCisKK2NvbmZpZyBERVZGUkVRX0VWRU5UX0VYWU5PU19QUE1VCisJYm9vbCAiRVhZTk9TIFBQTVUgKFBsYXRmb3JtIFBlcmZvcm1hbmNlIE1vbml0b3JpbmcgVW5pdCkgREVWRlJFUSBldmVudCBEcml2ZXIiCisJZGVwZW5kcyBvbiBBUkNIX0VYWU5PUworCXNlbGVjdCBQTV9PUFAKKwloZWxwCisJICBUaGlzIGFkZCB0aGUgZGV2ZnJlcS1ldmVudCBkcml2ZXIgZm9yIEV4eW5vcyBTb0MuIEl0IHByb3ZpZGVzIFBQTVUKKwkgIChQbGF0Zm9ybSBQZXJmb3JtYW5jZSBNb25pdG9yaW5nIFVuaXQpIGNvdW50ZXJzIHRvIGVzdGltYXRlIHRoZQorCSAgdXRpbGl6YXRpb24gb2YgZWFjaCBtb2R1bGUuCisKK2VuZGlmICMgUE1fREVWRlJFUV9FVkVOVApkaWZmIC0tZ2l0IGEvZHJpdmVycy9kZXZmcmVxL2V2ZW50L01ha2VmaWxlIGIvZHJpdmVycy9kZXZmcmVxL2V2ZW50L01ha2VmaWxlCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmJlMTQ2ZWEKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2RldmZyZXEvZXZlbnQvTWFrZWZpbGUKQEAgLTAsMCArMSwyIEBACisjIEV4eW5vcyBERVZGUkVRIEV2ZW50IERyaXZlcnMKK29iai0kKENPTkZJR19ERVZGUkVRX0VWRU5UX0VYWU5PU19QUE1VKSArPSBleHlub3MtcHBtdS5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL2RldmZyZXEvZXZlbnQvZXh5bm9zLXBwbXUuYyBiL2RyaXZlcnMvZGV2ZnJlcS9ldmVudC9leHlub3MtcHBtdS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjEzNWJlMGEKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2RldmZyZXEvZXZlbnQvZXh5bm9zLXBwbXUuYwpAQCAtMCwwICsxLDM3NCBAQAorLyoKKyAqIGV4eW5vc19wcG11LmMgLSBFWFlOT1MgUFBNVSAoUGxhdGZvcm0gUGVyZm9ybWFuY2UgTW9uaXRvcmluZyBVbml0KSBzdXBwb3J0CisgKgorICogQ29weXJpZ2h0IChjKSAyMDE0IFNhbXN1bmcgRWxlY3Ryb25pY3MgQ28uLCBMdGQuCisgKiBBdXRob3IgOiBDaGFud29vIENob2kgPGN3MDAuY2hvaUBzYW1zdW5nLmNvbT4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorICoKKyAqIFRoaXMgZHJpdmVyIGlzIGJhc2VkIG9uIGRyaXZlcnMvZGV2ZnJlcS9leHlub3MvZXh5bm9zX3BwbXUuYworICovCisKKyNpbmNsdWRlIDxsaW51eC9jbGsuaD4KKyNpbmNsdWRlIDxsaW51eC9pby5oPgorI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L211dGV4Lmg+CisjaW5jbHVkZSA8bGludXgvb2ZfYWRkcmVzcy5oPgorI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L3N1c3BlbmQuaD4KKyNpbmNsdWRlIDxsaW51eC9kZXZmcmVxLWV2ZW50Lmg+CisKKyNpbmNsdWRlICJleHlub3MtcHBtdS5oIgorCitzdHJ1Y3QgZXh5bm9zX3BwbXVfZGF0YSB7CisJdm9pZCBfX2lvbWVtICpiYXNlOworCXN0cnVjdCBjbGsgKmNsazsKK307CisKK3N0cnVjdCBleHlub3NfcHBtdSB7CisJc3RydWN0IGRldmZyZXFfZXZlbnRfZGV2ICoqZWRldjsKKwlzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kZXNjICpkZXNjOworCXVuc2lnbmVkIGludCBudW1fZXZlbnRzOworCisJc3RydWN0IGRldmljZSAqZGV2OworCXN0cnVjdCBtdXRleCBsb2NrOworCisJc3RydWN0IGV4eW5vc19wcG11X2RhdGEgcHBtdTsKK307CisKKyNkZWZpbmUgUFBNVV9FVkVOVChuYW1lKQkJCVwKKwl7ICJwcG11LWV2ZW50MC0iI25hbWUsIFBQTVVfUE1OQ05UMCB9LAlcCisJeyAicHBtdS1ldmVudDEtIiNuYW1lLCBQUE1VX1BNTkNOVDEgfSwJXAorCXsgInBwbXUtZXZlbnQyLSIjbmFtZSwgUFBNVV9QTU5DTlQyIH0sCVwKKwl7ICJwcG11LWV2ZW50My0iI25hbWUsIFBQTVVfUE1OQ05UMyB9CisKK3N0cnVjdCBfX2V4eW5vc19wcG11X2V2ZW50cyB7CisJY2hhciAqbmFtZTsKKwlpbnQgaWQ7Cit9IHBwbXVfZXZlbnRzW10gPSB7CisJLyogRm9yIEV4eW5vczMyNTAsIEV4eW5vczQgYW5kIEV4eW5vczUyNjAgKi8KKwlQUE1VX0VWRU5UKGczZCksCisJUFBNVV9FVkVOVChmc3lzKSwKKworCS8qIEZvciBFeHlub3M0IFNvQ3MgYW5kIEV4eW5vczMyNTAgKi8KKwlQUE1VX0VWRU5UKGRtYzApLAorCVBQTVVfRVZFTlQoZG1jMSksCisJUFBNVV9FVkVOVChjcHUpLAorCVBQTVVfRVZFTlQocmlnaHRidXMpLAorCVBQTVVfRVZFTlQobGVmdGJ1cyksCisJUFBNVV9FVkVOVChsY2QwKSwKKwlQUE1VX0VWRU5UKGNhbWlmKSwKKworCS8qIE9ubHkgZm9yIEV4eW5vczMyNTAgYW5kIEV4eW5vczUyNjAgKi8KKwlQUE1VX0VWRU5UKG1mYyksCisKKwkvKiBPbmx5IGZvciBFeHlub3M0IFNvQ3MgKi8KKwlQUE1VX0VWRU5UKG1mYy1sZWZ0KSwKKwlQUE1VX0VWRU5UKG1mYy1yaWdodCksCisKKwkvKiBPbmx5IGZvciBFeHlub3M1MjYwIFNvQ3MgKi8KKwlQUE1VX0VWRU5UKGRyZXgwLXMwKSwKKwlQUE1VX0VWRU5UKGRyZXgwLXMxKSwKKwlQUE1VX0VWRU5UKGRyZXgxLXMwKSwKKwlQUE1VX0VWRU5UKGRyZXgxLXMxKSwKKwlQUE1VX0VWRU5UKGVhZ2xlKSwKKwlQUE1VX0VWRU5UKGtmYyksCisJUFBNVV9FVkVOVChpc3ApLAorCVBQTVVfRVZFTlQoZmltYyksCisJUFBNVV9FVkVOVChnc2NsKSwKKwlQUE1VX0VWRU5UKG1zY2wpLAorCVBQTVVfRVZFTlQoZmltZDB4KSwKKwlQUE1VX0VWRU5UKGZpbWQxeCksCisJeyAvKiBzZW50aW5lbCAqLyB9LAorfTsKKworc3RhdGljIGludCBleHlub3NfcHBtdV9maW5kX3BwbXVfaWQoc3RydWN0IGRldmZyZXFfZXZlbnRfZGV2ICplZGV2KQoreworCWludCBpOworCisJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUocHBtdV9ldmVudHMpOyBpKyspCisJCWlmICghc3RyY21wKGVkZXYtPmRlc2MtPm5hbWUsIHBwbXVfZXZlbnRzW2ldLm5hbWUpKQorCQkJcmV0dXJuIHBwbXVfZXZlbnRzW2ldLmlkOworCisJcmV0dXJuIC1FSU5WQUw7Cit9CisKK3N0YXRpYyBpbnQgZXh5bm9zX3BwbXVfZGlzYWJsZShzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kZXYgKmVkZXYpCit7CisJc3RydWN0IGV4eW5vc19wcG11ICppbmZvID0gZGV2ZnJlcV9ldmVudF9nZXRfZHJ2ZGF0YShlZGV2KTsKKwl1MzIgcG1uYzsKKworCS8qIERpc2FibGUgYWxsIGNvdW50ZXJzICovCisJX19yYXdfd3JpdGVsKFBQTVVfQ0NOVF9NQVNLIHwKKwkJICAgICBQUE1VX1BNQ05UMF9NQVNLIHwKKwkJICAgICBQUE1VX1BNQ05UMV9NQVNLIHwKKwkJICAgICBQUE1VX1BNQ05UMl9NQVNLIHwKKwkJICAgICBQUE1VX1BNQ05UM19NQVNLLAorCQkgICAgIGluZm8tPnBwbXUuYmFzZSArIFBQTVVfQ05URU5DKTsKKworCS8qIERpc2FibGUgUFBNVSAqLworCXBtbmMgPSBfX3Jhd19yZWFkbChpbmZvLT5wcG11LmJhc2UgKyBQUE1VX1BNTkMpOworCXBtbmMgJj0gflBQTVVfUE1OQ19FTkFCTEVfTUFTSzsKKwlfX3Jhd193cml0ZWwocG1uYywgaW5mby0+cHBtdS5iYXNlICsgUFBNVV9QTU5DKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGV4eW5vc19wcG11X3NldF9ldmVudChzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kZXYgKmVkZXYpCit7CisJc3RydWN0IGV4eW5vc19wcG11ICppbmZvID0gZGV2ZnJlcV9ldmVudF9nZXRfZHJ2ZGF0YShlZGV2KTsKKwlpbnQgaWQgPSBleHlub3NfcHBtdV9maW5kX3BwbXVfaWQoZWRldik7CisJdTMyIHBtbmMsIGNudGVuczsKKworCWlmIChpZCA8IDApCisJCXJldHVybiBpZDsKKworCS8qIEVuYWJsZSBzcGVjaWZpYyBjb3VudGVyICovCisJY250ZW5zID0gX19yYXdfcmVhZGwoaW5mby0+cHBtdS5iYXNlICsgUFBNVV9DTlRFTlMpOworCWNudGVucyB8PSAoUFBNVV9DQ05UX01BU0sgfCAoUFBNVV9FTkFCTEUgPDwgaWQpKTsKKwlfX3Jhd193cml0ZWwoY250ZW5zLCBpbmZvLT5wcG11LmJhc2UgKyBQUE1VX0NOVEVOUyk7CisKKwkvKiBTZXQgdGhlIGV2ZW50IG9mIFJlYWQvV3JpdGUgZGF0YSBjb3VudCAgKi8KKwlfX3Jhd193cml0ZWwoUFBNVV9ST19EQVRBX0NOVCB8IFBQTVVfV09fREFUQV9DTlQsCisJCQlpbmZvLT5wcG11LmJhc2UgKyBQUE1VX0JFVlR4U0VMKGlkKSk7CisKKwkvKiBSZXNldCBjeWNsZSBjb3VudGVyL3BlcmZvcm1hbmNlIGNvdW50ZXIgYW5kIGVuYWJsZSBQUE1VICovCisJcG1uYyA9IF9fcmF3X3JlYWRsKGluZm8tPnBwbXUuYmFzZSArIFBQTVVfUE1OQyk7CisJcG1uYyAmPSB+KFBQTVVfUE1OQ19FTkFCTEVfTUFTSworCQkJfCBQUE1VX1BNTkNfQ09VTlRFUl9SRVNFVF9NQVNLCisJCQl8IFBQTVVfUE1OQ19DQ19SRVNFVF9NQVNLKTsKKwlwbW5jIHw9IChQUE1VX0VOQUJMRSA8PCBQUE1VX1BNTkNfRU5BQkxFX1NISUZUKTsKKwlwbW5jIHw9IChQUE1VX0VOQUJMRSA8PCBQUE1VX1BNTkNfQ09VTlRFUl9SRVNFVF9TSElGVCk7CisJcG1uYyB8PSAoUFBNVV9FTkFCTEUgPDwgUFBNVV9QTU5DX0NDX1JFU0VUX1NISUZUKTsKKwlfX3Jhd193cml0ZWwocG1uYywgaW5mby0+cHBtdS5iYXNlICsgUFBNVV9QTU5DKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGV4eW5vc19wcG11X2dldF9ldmVudChzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kZXYgKmVkZXYsCisJCQkJc3RydWN0IGRldmZyZXFfZXZlbnRfZGF0YSAqZWRhdGEpCit7CisJc3RydWN0IGV4eW5vc19wcG11ICppbmZvID0gZGV2ZnJlcV9ldmVudF9nZXRfZHJ2ZGF0YShlZGV2KTsKKwlpbnQgaWQgPSBleHlub3NfcHBtdV9maW5kX3BwbXVfaWQoZWRldik7CisJdTMyIHBtbmMsIGNudGVuYzsKKworCWlmIChpZCA8IDApCisJCXJldHVybiAtRUlOVkFMOworCisJLyogRGlzYWJsZSBQUE1VICovCisJcG1uYyA9IF9fcmF3X3JlYWRsKGluZm8tPnBwbXUuYmFzZSArIFBQTVVfUE1OQyk7CisJcG1uYyAmPSB+UFBNVV9QTU5DX0VOQUJMRV9NQVNLOworCV9fcmF3X3dyaXRlbChwbW5jLCBpbmZvLT5wcG11LmJhc2UgKyBQUE1VX1BNTkMpOworCisJLyogUmVhZCBjeWNsZSBjb3VudCAqLworCWVkYXRhLT50b3RhbF9jb3VudCA9IF9fcmF3X3JlYWRsKGluZm8tPnBwbXUuYmFzZSArIFBQTVVfQ0NOVCk7CisKKwkvKiBSZWFkIHBlcmZvcm1hbmNlIGNvdW50ICovCisJc3dpdGNoIChpZCkgeworCWNhc2UgUFBNVV9QTU5DTlQwOgorCWNhc2UgUFBNVV9QTU5DTlQxOgorCWNhc2UgUFBNVV9QTU5DTlQyOgorCQllZGF0YS0+bG9hZF9jb3VudAorCQkJPSBfX3Jhd19yZWFkbChpbmZvLT5wcG11LmJhc2UgKyBQUE1VX1BNTkNUKGlkKSk7CisJCWJyZWFrOworCWNhc2UgUFBNVV9QTU5DTlQzOgorCQllZGF0YS0+bG9hZF9jb3VudCA9CisJCQkoKF9fcmF3X3JlYWRsKGluZm8tPnBwbXUuYmFzZSArIFBQTVVfUE1DTlQzX0hJR0gpIDw8IDgpCisJCQl8IF9fcmF3X3JlYWRsKGluZm8tPnBwbXUuYmFzZSArIFBQTVVfUE1DTlQzX0xPVykpOworCQlicmVhazsKKwlkZWZhdWx0OgorCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwkvKiBEaXNhYmxlIHNwZWNpZmljIGNvdW50ZXIgKi8KKwljbnRlbmMgPSBfX3Jhd19yZWFkbChpbmZvLT5wcG11LmJhc2UgKyBQUE1VX0NOVEVOQyk7CisJY250ZW5jIHw9IChQUE1VX0NDTlRfTUFTSyB8IChQUE1VX0VOQUJMRSA8PCBpZCkpOworCV9fcmF3X3dyaXRlbChjbnRlbmMsIGluZm8tPnBwbXUuYmFzZSArIFBQTVVfQ05URU5DKTsKKworCWRldl9kYmcoJmVkZXYtPmRldiwgIiVzIChldmVudDogJWxkLyVsZClcbiIsIGVkZXYtPmRlc2MtPm5hbWUsCisJCQkJCWVkYXRhLT5sb2FkX2NvdW50LCBlZGF0YS0+dG90YWxfY291bnQpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9vcHMgZXh5bm9zX3BwbXVfb3BzID0geworCS5kaXNhYmxlID0gZXh5bm9zX3BwbXVfZGlzYWJsZSwKKwkuc2V0X2V2ZW50ID0gZXh5bm9zX3BwbXVfc2V0X2V2ZW50LAorCS5nZXRfZXZlbnQgPSBleHlub3NfcHBtdV9nZXRfZXZlbnQsCit9OworCitzdGF0aWMgaW50IG9mX2dldF9kZXZmcmVxX2V2ZW50cyhzdHJ1Y3QgZGV2aWNlX25vZGUgKm5wLAorCQkJCSBzdHJ1Y3QgZXh5bm9zX3BwbXUgKmluZm8pCit7CisJc3RydWN0IGRldmZyZXFfZXZlbnRfZGVzYyAqZGVzYzsKKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSBpbmZvLT5kZXY7CisJc3RydWN0IGRldmljZV9ub2RlICpldmVudHNfbnAsICpub2RlOworCWludCBpLCBqLCBjb3VudDsKKworCWV2ZW50c19ucCA9IG9mX2dldF9jaGlsZF9ieV9uYW1lKG5wLCAiZXZlbnRzIik7CisJaWYgKCFldmVudHNfbnApIHsKKwkJZGV2X2VycihkZXYsCisJCQkiZmFpbGVkIHRvIGdldCBjaGlsZCBub2RlIG9mIGRldmZyZXEtZXZlbnQgZGV2aWNlc1xuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCWNvdW50ID0gb2ZfZ2V0X2NoaWxkX2NvdW50KGV2ZW50c19ucCk7CisJZGVzYyA9IGRldm1fa3phbGxvYyhkZXYsIHNpemVvZigqZGVzYykgKiBjb3VudCwgR0ZQX0tFUk5FTCk7CisJaWYgKCFkZXNjKQorCQlyZXR1cm4gLUVOT01FTTsKKwlpbmZvLT5udW1fZXZlbnRzID0gY291bnQ7CisKKwlqID0gMDsKKwlmb3JfZWFjaF9jaGlsZF9vZl9ub2RlKGV2ZW50c19ucCwgbm9kZSkgeworCQlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShwcG11X2V2ZW50cyk7IGkrKykgeworCQkJaWYgKCFwcG11X2V2ZW50c1tpXS5uYW1lKQorCQkJCWNvbnRpbnVlOworCisJCQlpZiAoIW9mX25vZGVfY21wKG5vZGUtPm5hbWUsIHBwbXVfZXZlbnRzW2ldLm5hbWUpKQorCQkJCWJyZWFrOworCQl9CisKKwkJaWYgKGkgPT0gQVJSQVlfU0laRShwcG11X2V2ZW50cykpIHsKKwkJCWRldl93YXJuKGRldiwKKwkJCQkiZG9uJ3Qga25vdyBob3cgdG8gY29uZmlndXJlIGV2ZW50cyA6ICVzXG4iLAorCQkJCW5vZGUtPm5hbWUpOworCQkJY29udGludWU7CisJCX0KKworCQlkZXNjW2pdLm9wcyA9ICZleHlub3NfcHBtdV9vcHM7CisJCWRlc2Nbal0uZHJpdmVyX2RhdGEgPSBpbmZvOworCisJCW9mX3Byb3BlcnR5X3JlYWRfc3RyaW5nKG5vZGUsICJldmVudC1uYW1lIiwgJmRlc2Nbal0ubmFtZSk7CisKKwkJaisrOworCisJCW9mX25vZGVfcHV0KG5vZGUpOworCX0KKwlpbmZvLT5kZXNjID0gZGVzYzsKKworCW9mX25vZGVfcHV0KGV2ZW50c19ucCk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBleHlub3NfcHBtdV9wYXJzZV9kdChzdHJ1Y3QgZXh5bm9zX3BwbXUgKmluZm8pCit7CisJc3RydWN0IGRldmljZSAqZGV2ID0gaW5mby0+ZGV2OworCXN0cnVjdCBkZXZpY2Vfbm9kZSAqbnAgPSBkZXYtPm9mX25vZGU7CisJaW50IHJldCA9IDA7CisKKwlpZiAoIW5wKSB7CisJCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIGZpbmQgZGV2aWNldHJlZSBub2RlXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJLyogTWFwcyB0aGUgbWVtb3J5IG1hcHBlZCBJTyB0byBjb250cm9sIFBQTVUgcmVnaXN0ZXIgKi8KKwlpbmZvLT5wcG11LmJhc2UgPSBvZl9pb21hcChucCwgMCk7CisJaWYgKElTX0VSUl9PUl9OVUxMKGluZm8tPnBwbXUuYmFzZSkpIHsKKwkJZGV2X2VycihkZXYsICJmYWlsZWQgdG8gbWFwIG1lbW9yeSByZWdpb25cbiIpOworCQlyZXR1cm4gLUVOT01FTTsKKwl9CisKKwlpbmZvLT5wcG11LmNsayA9IGRldm1fY2xrX2dldChkZXYsICJwcG11Iik7CisJaWYgKElTX0VSUihpbmZvLT5wcG11LmNsaykpIHsKKwkJaW5mby0+cHBtdS5jbGsgPSBOVUxMOworCQlkZXZfd2FybihkZXYsICJjYW5ub3QgZ2V0IFBQTVUgY2xvY2tcbiIpOworCX0KKworCXJldCA9IG9mX2dldF9kZXZmcmVxX2V2ZW50cyhucCwgaW5mbyk7CisJaWYgKHJldCA8IDApIHsKKwkJZGV2X2VycihkZXYsICJmYWlsZWQgdG8gcGFyc2UgZXh5bm9zIHBwbXUgZHQgbm9kZVxuIik7CisJCWdvdG8gZXJyOworCX0KKworCXJldHVybiAwOworCitlcnI6CisJaW91bm1hcChpbmZvLT5wcG11LmJhc2UpOworCisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGludCBleHlub3NfcHBtdV9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQoreworCXN0cnVjdCBleHlub3NfcHBtdSAqaW5mbzsKKwlzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kZXYgKiplZGV2OworCXN0cnVjdCBkZXZmcmVxX2V2ZW50X2Rlc2MgKmRlc2M7CisJaW50IGksIHJldCA9IDAsIHNpemU7CisKKwlpbmZvID0gZGV2bV9remFsbG9jKCZwZGV2LT5kZXYsIHNpemVvZigqaW5mbyksIEdGUF9LRVJORUwpOworCWlmICghaW5mbykKKwkJcmV0dXJuIC1FTk9NRU07CisKKwltdXRleF9pbml0KCZpbmZvLT5sb2NrKTsKKwlpbmZvLT5kZXYgPSAmcGRldi0+ZGV2OworCisJLyogUGFyc2UgZHQgZGF0YSB0byBnZXQgcmVzb3VyY2UgKi8KKwlyZXQgPSBleHlub3NfcHBtdV9wYXJzZV9kdChpbmZvKTsKKwlpZiAocmV0IDwgMCkgeworCQlkZXZfZXJyKCZwZGV2LT5kZXYsCisJCQkiZmFpbGVkIHRvIHBhcnNlIGRldmljZXRyZWUgZm9yIHJlc291cmNlXG4iKTsKKwkJcmV0dXJuIHJldDsKKwl9CisJZGVzYyA9IGluZm8tPmRlc2M7CisKKwlzaXplID0gc2l6ZW9mKHN0cnVjdCBkZXZmcmVxX2V2ZW50X2RldiAqKSAqIGluZm8tPm51bV9ldmVudHM7CisJaW5mby0+ZWRldiA9IGRldm1fa3phbGxvYygmcGRldi0+ZGV2LCBzaXplLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWluZm8tPmVkZXYpIHsKKwkJZGV2X2VycigmcGRldi0+ZGV2LAorCQkJImZhaWxlZCB0byBhbGxvY2F0ZSBtZW1vcnkgZGV2ZnJlcS1ldmVudCBkZXZpY2VzXG4iKTsKKwkJcmV0dXJuIC1FTk9NRU07CisJfQorCWVkZXYgPSBpbmZvLT5lZGV2OworCXBsYXRmb3JtX3NldF9kcnZkYXRhKHBkZXYsIGluZm8pOworCisJZm9yIChpID0gMDsgaSA8IGluZm8tPm51bV9ldmVudHM7IGkrKykgeworCQllZGV2W2ldID0gZGV2bV9kZXZmcmVxX2V2ZW50X2FkZF9lZGV2KCZwZGV2LT5kZXYsICZkZXNjW2ldKTsKKwkJaWYgKElTX0VSUihlZGV2KSkgeworCQkJcmV0ID0gUFRSX0VSUihlZGV2KTsKKwkJCWRldl9lcnIoJnBkZXYtPmRldiwKKwkJCQkiZmFpbGVkIHRvIGFkZCBkZXZmcmVxLWV2ZW50IGRldmljZVxuIik7CisJCQlnb3RvIGVycjsKKwkJfQorCX0KKworCWNsa19wcmVwYXJlX2VuYWJsZShpbmZvLT5wcG11LmNsayk7CisKKwlyZXR1cm4gMDsKK2VycjoKKwlpb3VubWFwKGluZm8tPnBwbXUuYmFzZSk7CisKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgaW50IGV4eW5vc19wcG11X3JlbW92ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQoreworCXN0cnVjdCBleHlub3NfcHBtdSAqaW5mbyA9IHBsYXRmb3JtX2dldF9kcnZkYXRhKHBkZXYpOworCisJY2xrX2Rpc2FibGVfdW5wcmVwYXJlKGluZm8tPnBwbXUuY2xrKTsKKwlpb3VubWFwKGluZm8tPnBwbXUuYmFzZSk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHN0cnVjdCBvZl9kZXZpY2VfaWQgZXh5bm9zX3BwbXVfaWRfbWF0Y2hbXSA9IHsKKwl7IC5jb21wYXRpYmxlID0gInNhbXN1bmcsZXh5bm9zLXBwbXUiLCB9LAorCXsgLyogc2VudGluZWwgKi8gfSwKK307CisKK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZHJpdmVyIGV4eW5vc19wcG11X2RyaXZlciA9IHsKKwkucHJvYmUJPSBleHlub3NfcHBtdV9wcm9iZSwKKwkucmVtb3ZlCT0gZXh5bm9zX3BwbXVfcmVtb3ZlLAorCS5kcml2ZXIgPSB7CisJCS5uYW1lCT0gImV4eW5vcy1wcG11IiwKKwkJLm9mX21hdGNoX3RhYmxlID0gZXh5bm9zX3BwbXVfaWRfbWF0Y2gsCisJfSwKK307Cittb2R1bGVfcGxhdGZvcm1fZHJpdmVyKGV4eW5vc19wcG11X2RyaXZlcik7CisKK01PRFVMRV9ERVNDUklQVElPTigiRXh5bm9zIFBQTVUoUGxhdGZvcm0gUGVyZm9ybWFuY2UgTW9uaXRvcmluZyBVbml0KSBkcml2ZXIiKTsKK01PRFVMRV9BVVRIT1IoIkNoYW53b28gQ2hvaSA8Y3cwMC5jaG9pQHNhbXN1bmcuY29tPiIpOworTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9kZXZmcmVxL2V2ZW50L2V4eW5vcy1wcG11LmggYi9kcml2ZXJzL2RldmZyZXEvZXZlbnQvZXh5bm9zLXBwbXUuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40ZTgzMWQ0Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9kZXZmcmVxL2V2ZW50L2V4eW5vcy1wcG11LmgKQEAgLTAsMCArMSw5MyBAQAorLyoKKyAqIGV4eW5vc19wcG11LmggLSBFWFlOT1MgUFBNVSBoZWFkZXIgZmlsZQorICoKKyAqIENvcHlyaWdodCAoYykgMjAxNSBTYW1zdW5nIEVsZWN0cm9uaWNzIENvLiwgTHRkLgorICogQXV0aG9yIDogQ2hhbndvbyBDaG9pIDxjdzAwLmNob2lAc2Ftc3VuZy5jb20+CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KKyAqLworCisjaWZuZGVmIF9fRVhZTk9TX1BQTVVfSF9fCisjZGVmaW5lIF9fRVhZTk9TX1BQTVVfSF9fCisKK2VudW0gcHBtdV9zdGF0ZSB7CisJUFBNVV9ESVNBQkxFID0gMCwKKwlQUE1VX0VOQUJMRSwKK307CisKK2VudW0gcHBtdV9jb3VudGVyIHsKKwlQUE1VX1BNTkNOVDAgPSAwLAorCVBQTVVfUE1OQ05UMSwKKwlQUE1VX1BNTkNOVDIsCisJUFBNVV9QTU5DTlQzLAorCisJUFBNVV9QTU5DTlRfTUFYLAorfTsKKworZW51bSBwcG11X2V2ZW50X3R5cGUgeworCVBQTVVfUk9fQlVTWV9DWUNMRV9DTlQJPSAweDAsCisJUFBNVV9XT19CVVNZX0NZQ0xFX0NOVAk9IDB4MSwKKwlQUE1VX1JXX0JVU1lfQ1lDTEVfQ05UCT0gMHgyLAorCVBQTVVfUk9fUkVRVUVTVF9DTlQJPSAweDMsCisJUFBNVV9XT19SRVFVRVNUX0NOVAk9IDB4NCwKKwlQUE1VX1JPX0RBVEFfQ05UCT0gMHg1LAorCVBQTVVfV09fREFUQV9DTlQJPSAweDYsCisJUFBNVV9ST19MQVRFTkNZCQk9IDB4MTIsCisJUFBNVV9XT19MQVRFTkNZCQk9IDB4MTYsCit9OworCitlbnVtIHBwbXVfcmVnIHsKKwkvKiBQUEMgY29udHJvbCByZWdpc3RlciAqLworCVBQTVVfUE1OQwkJPSAweDAwLAorCVBQTVVfQ05URU5TCQk9IDB4MTAsCisJUFBNVV9DTlRFTkMJCT0gMHgyMCwKKwlQUE1VX0lOVEVOUwkJPSAweDMwLAorCVBQTVVfSU5URU5DCQk9IDB4NDAsCisJUFBNVV9GTEFHCQk9IDB4NTAsCisKKwkvKiBDeWNsZSBDb3VudGVyIGFuZCBQZXJmb3JtYW5jZSBFdmVudCBDb3VudGVyIFJlZ2lzdGVyICovCisJUFBNVV9DQ05UCQk9IDB4MTAwLAorCVBQTVVfUE1DTlQwCQk9IDB4MTEwLAorCVBQTVVfUE1DTlQxCQk9IDB4MTIwLAorCVBQTVVfUE1DTlQyCQk9IDB4MTMwLAorCVBQTVVfUE1DTlQzX0hJR0gJPSAweDE0MCwKKwlQUE1VX1BNQ05UM19MT1cJCT0gMHgxNTAsCisKKwkvKiBCdXMgRXZlbnQgR2VuZXJhdG9yICovCisJUFBNVV9CRVZUMFNFTAkJPSAweDEwMDAsCisJUFBNVV9CRVZUMVNFTAkJPSAweDExMDAsCisJUFBNVV9CRVZUMlNFTAkJPSAweDEyMDAsCisJUFBNVV9CRVZUM1NFTAkJPSAweDEzMDAsCisJUFBNVV9DT1VOVEVSX1JFU0VUCT0gMHgxODEwLAorCVBQTVVfUkVBRF9PVkVSRkxPV19DTlQJPSAweDE4MTAsCisJUFBNVV9SRUFEX1VOREVSRkxPV19DTlQJPSAweDE4MTQsCisJUFBNVV9XUklURV9PVkVSRkxPV19DTlQJPSAweDE4NTAsCisJUFBNVV9XUklURV9VTkRFUkZMT1dfQ05UID0gMHgxODU0LAorCVBQTVVfUkVBRF9QRU5ESU5HX0NOVAk9IDB4MTg4MCwKKwlQUE1VX1dSSVRFX1BFTkRJTkdfQ05UCT0gMHgxODg0Cit9OworCisvKiBQTU5DIHJlZ2lzdGVyICovCisjZGVmaW5lIFBQTVVfUE1OQ19DQ19SRVNFVF9TSElGVAkyCisjZGVmaW5lIFBQTVVfUE1OQ19DT1VOVEVSX1JFU0VUX1NISUZUCTEKKyNkZWZpbmUgUFBNVV9QTU5DX0VOQUJMRV9TSElGVAkJMAorI2RlZmluZSBQUE1VX1BNTkNfU1RBUlRfTU9ERV9NQVNLCUJJVCgxNikKKyNkZWZpbmUgUFBNVV9QTU5DX0NDX0RJVklERVJfTUFTSwlCSVQoMykKKyNkZWZpbmUgUFBNVV9QTU5DX0NDX1JFU0VUX01BU0sJCUJJVCgyKQorI2RlZmluZSBQUE1VX1BNTkNfQ09VTlRFUl9SRVNFVF9NQVNLCUJJVCgxKQorI2RlZmluZSBQUE1VX1BNTkNfRU5BQkxFX01BU0sJCUJJVCgwKQorCisvKiBDTlRFTlMvQ05URU5DL0lOVEVOUy9JTlRFTkMvRkxBRyByZWdpc3RlciAqLworI2RlZmluZSBQUE1VX0NDTlRfTUFTSwkJCUJJVCgzMSkKKyNkZWZpbmUgUFBNVV9QTUNOVDNfTUFTSwkJQklUKDMpCisjZGVmaW5lIFBQTVVfUE1DTlQyX01BU0sJCUJJVCgyKQorI2RlZmluZSBQUE1VX1BNQ05UMV9NQVNLCQlCSVQoMSkKKyNkZWZpbmUgUFBNVV9QTUNOVDBfTUFTSwkJQklUKDApCisKKy8qIFBQTVVfUE1OQ1R4L1BQTVVfQkVUeFNFTCByZWdpc3RlcnMgKi8KKyNkZWZpbmUgUFBNVV9QTU5DVCh4KQkJCShQUE1VX1BNQ05UMCArICgweDEwICogeCkpCisjZGVmaW5lIFBQTVVfQkVWVHhTRUwoeCkJCShQUE1VX0JFVlQwU0VMICsgKDB4MTAwICogeCkpCisKKyNlbmRpZiAvKiBfX0VYWU5PU19QUE1VX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9kZXZmcmVxL3RlZ3JhLWRldmZyZXEuYyBiL2RyaXZlcnMvZGV2ZnJlcS90ZWdyYS1kZXZmcmVxLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMzQ3OTA5NgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZGV2ZnJlcS90ZWdyYS1kZXZmcmVxLmMKQEAgLTAsMCArMSw3MTggQEAKKy8qCisgKiBBIGRldmZyZXEgZHJpdmVyIGZvciBOVklESUEgVGVncmEgU29DcworICoKKyAqIENvcHlyaWdodCAoYykgMjAxNCBOVklESUEgQ09SUE9SQVRJT04uIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMTQgR29vZ2xlLCBJbmMKKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSwKKyAqIHZlcnNpb24gMiwgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIGl0IHdpbGwgYmUgdXNlZnVsLCBidXQgV0lUSE9VVAorICogQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yCisgKiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gU2VlIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IKKyAqIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW0uIElmIG5vdCwgc2VlIDxodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvPi4KKyAqCisgKi8KKworI2luY2x1ZGUgPGxpbnV4L2Nsay5oPgorI2luY2x1ZGUgPGxpbnV4L2NwdWZyZXEuaD4KKyNpbmNsdWRlIDxsaW51eC9kZXZmcmVxLmg+CisjaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CisjaW5jbHVkZSA8bGludXgvaW8uaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9wbV9vcHAuaD4KKyNpbmNsdWRlIDxsaW51eC9yZXNldC5oPgorCisjaW5jbHVkZSAiZ292ZXJub3IuaCIKKworI2RlZmluZSBBQ1RNT05fR0xCX1NUQVRVUwkJCQkJMHgwCisjZGVmaW5lIEFDVE1PTl9HTEJfUEVSSU9EX0NUUkwJCQkJCTB4NAorCisjZGVmaW5lIEFDVE1PTl9ERVZfQ1RSTAkJCQkJCTB4MAorI2RlZmluZSBBQ1RNT05fREVWX0NUUkxfS19WQUxfU0hJRlQJCQkJMTAKKyNkZWZpbmUgQUNUTU9OX0RFVl9DVFJMX0VOQl9QRVJJT0RJQwkJCQlCSVQoMTgpCisjZGVmaW5lIEFDVE1PTl9ERVZfQ1RSTF9BVkdfQkVMT1dfV01BUktfRU4JCQlCSVQoMjApCisjZGVmaW5lIEFDVE1PTl9ERVZfQ1RSTF9BVkdfQUJPVkVfV01BUktfRU4JCQlCSVQoMjEpCisjZGVmaW5lIEFDVE1PTl9ERVZfQ1RSTF9DT05TRUNVVElWRV9CRUxPV19XTUFSS19OVU1fU0hJRlQJMjMKKyNkZWZpbmUgQUNUTU9OX0RFVl9DVFJMX0NPTlNFQ1VUSVZFX0FCT1ZFX1dNQVJLX05VTV9TSElGVAkyNgorI2RlZmluZSBBQ1RNT05fREVWX0NUUkxfQ09OU0VDVVRJVkVfQkVMT1dfV01BUktfRU4JCUJJVCgyOSkKKyNkZWZpbmUgQUNUTU9OX0RFVl9DVFJMX0NPTlNFQ1VUSVZFX0FCT1ZFX1dNQVJLX0VOCQlCSVQoMzApCisjZGVmaW5lIEFDVE1PTl9ERVZfQ1RSTF9FTkIJCQkJCUJJVCgzMSkKKworI2RlZmluZSBBQ1RNT05fREVWX1VQUEVSX1dNQVJLCQkJCQkweDQKKyNkZWZpbmUgQUNUTU9OX0RFVl9MT1dFUl9XTUFSSwkJCQkJMHg4CisjZGVmaW5lIEFDVE1PTl9ERVZfSU5JVF9BVkcJCQkJCTB4YworI2RlZmluZSBBQ1RNT05fREVWX0FWR19VUFBFUl9XTUFSSwkJCQkweDEwCisjZGVmaW5lIEFDVE1PTl9ERVZfQVZHX0xPV0VSX1dNQVJLCQkJCTB4MTQKKyNkZWZpbmUgQUNUTU9OX0RFVl9DT1VOVF9XRUlHSFQJCQkJCTB4MTgKKyNkZWZpbmUgQUNUTU9OX0RFVl9BVkdfQ09VTlQJCQkJCTB4MjAKKyNkZWZpbmUgQUNUTU9OX0RFVl9JTlRSX1NUQVRVUwkJCQkJMHgyNAorCisjZGVmaW5lIEFDVE1PTl9JTlRSX1NUQVRVU19DTEVBUgkJCQkweGZmZmZmZmZmCisKKyNkZWZpbmUgQUNUTU9OX0RFVl9JTlRSX0NPTlNFQ1VUSVZFX1VQUEVSCQkJQklUKDMxKQorI2RlZmluZSBBQ1RNT05fREVWX0lOVFJfQ09OU0VDVVRJVkVfTE9XRVIJCQlCSVQoMzApCisKKyNkZWZpbmUgQUNUTU9OX0FCT1ZFX1dNQVJLX1dJTkRPVwkJCQkxCisjZGVmaW5lIEFDVE1PTl9CRUxPV19XTUFSS19XSU5ET1cJCQkJMworI2RlZmluZSBBQ1RNT05fQk9PU1RfRlJFUV9TVEVQCQkJCQkxNjAwMAorCisvKiBhY3Rpdml0eSBjb3VudGVyIGlzIGluY3JlbWVudGVkIGV2ZXJ5IDI1NiBtZW1vcnkgdHJhbnNhY3Rpb25zLCBhbmQgZWFjaAorICogdHJhbnNhY3Rpb24gdGFrZXMgNCBFTUMgY2xvY2tzIGZvciBUZWdyYTEyNDsgU28gdGhlIENPVU5UX1dFSUdIVCBpcworICogNCAqIDI1NiA9IDEwMjQuCisgKi8KKyNkZWZpbmUgQUNUTU9OX0NPVU5UX1dFSUdIVAkJCQkJMHg0MDAKKworLyoKKyAqIEFDVE1PTl9BVkVSQUdFX1dJTkRPV19MT0cyOiBkZWZhdWx0IHZhbHVlIGZvciBAREVWX0NUUkxfS19WQUwsIHdoaWNoCisgKiB0cmFuc2xhdGVzIHRvIDIgXiAoS19WQUwgKyAxKS4gZXg6IDIgXiAoNiArIDEpID0gMTI4CisgKi8KKyNkZWZpbmUgQUNUTU9OX0FWRVJBR0VfV0lORE9XX0xPRzIJCQk2CisjZGVmaW5lIEFDVE1PTl9TQU1QTElOR19QRVJJT0QJCQkJMTIgLyogbXMgKi8KKyNkZWZpbmUgQUNUTU9OX0RFRkFVTFRfQVZHX0JBTkQJCQkJNiAgLyogMS8xMCBvZiAlICovCisKKyNkZWZpbmUgS0haCQkJCQkJCTEwMDAKKworLyogQXNzdW1lIHRoYXQgdGhlIGJ1cyBpcyBzYXR1cmF0ZWQgaWYgdGhlIHV0aWxpemF0aW9uIGlzIDI1JSAqLworI2RlZmluZSBCVVNfU0FUVVJBVElPTl9SQVRJTwkJCQkJMjUKKworLyoqCisgKiBzdHJ1Y3QgdGVncmFfZGV2ZnJlcV9kZXZpY2VfY29uZmlnIC0gY29uZmlndXJhdGlvbiBzcGVjaWZpYyB0byBhbiBBQ1RNT04KKyAqIGRldmljZQorICoKKyAqIENvZWZmaWNpZW50cyBhbmQgdGhyZXNob2xkcyBhcmUgaW4gJQorICovCitzdHJ1Y3QgdGVncmFfZGV2ZnJlcV9kZXZpY2VfY29uZmlnIHsKKwl1MzIJCW9mZnNldDsKKwl1MzIJCWlycV9tYXNrOworCisJdW5zaWduZWQgaW50CWJvb3N0X3VwX2NvZWZmOworCXVuc2lnbmVkIGludAlib29zdF9kb3duX2NvZWZmOworCXVuc2lnbmVkIGludAlib29zdF91cF90aHJlc2hvbGQ7CisJdW5zaWduZWQgaW50CWJvb3N0X2Rvd25fdGhyZXNob2xkOworCXUzMgkJYXZnX2RlcGVuZGVuY3lfdGhyZXNob2xkOworfTsKKworZW51bSB0ZWdyYV9hY3Rtb25fZGV2aWNlIHsKKwlNQ0FMTCA9IDAsCisJTUNDUFUsCit9OworCitzdGF0aWMgc3RydWN0IHRlZ3JhX2RldmZyZXFfZGV2aWNlX2NvbmZpZyBhY3Rtb25fZGV2aWNlX2NvbmZpZ3NbXSA9IHsKKwl7CisJCS8qIE1DQUxMICovCisJCS5vZmZzZXQgPSAweDFjMCwKKwkJLmlycV9tYXNrID0gMSA8PCAyNiwKKwkJLmJvb3N0X3VwX2NvZWZmID0gMjAwLAorCQkuYm9vc3RfZG93bl9jb2VmZiA9IDUwLAorCQkuYm9vc3RfdXBfdGhyZXNob2xkID0gNjAsCisJCS5ib29zdF9kb3duX3RocmVzaG9sZCA9IDQwLAorCX0sCisJeworCQkvKiBNQ0NQVSAqLworCQkub2Zmc2V0ID0gMHgyMDAsCisJCS5pcnFfbWFzayA9IDEgPDwgMjUsCisJCS5ib29zdF91cF9jb2VmZiA9IDgwMCwKKwkJLmJvb3N0X2Rvd25fY29lZmYgPSA5MCwKKwkJLmJvb3N0X3VwX3RocmVzaG9sZCA9IDI3LAorCQkuYm9vc3RfZG93bl90aHJlc2hvbGQgPSAxMCwKKwkJLmF2Z19kZXBlbmRlbmN5X3RocmVzaG9sZCA9IDUwMDAwLAorCX0sCit9OworCisvKioKKyAqIHN0cnVjdCB0ZWdyYV9kZXZmcmVxX2RldmljZSAtIHN0YXRlIHNwZWNpZmljIHRvIGFuIEFDVE1PTiBkZXZpY2UKKyAqCisgKiBGcmVxdWVuY2llcyBhcmUgaW4ga0h6LgorICovCitzdHJ1Y3QgdGVncmFfZGV2ZnJlcV9kZXZpY2UgeworCWNvbnN0IHN0cnVjdCB0ZWdyYV9kZXZmcmVxX2RldmljZV9jb25maWcgKmNvbmZpZzsKKworCXZvaWQgX19pb21lbQkqcmVnczsKKwl1MzIJCWF2Z19iYW5kX2ZyZXE7CisJdTMyCQlhdmdfY291bnQ7CisKKwl1bnNpZ25lZCBsb25nCXRhcmdldF9mcmVxOworCXVuc2lnbmVkIGxvbmcJYm9vc3RfZnJlcTsKK307CisKK3N0cnVjdCB0ZWdyYV9kZXZmcmVxIHsKKwlzdHJ1Y3QgZGV2ZnJlcQkJKmRldmZyZXE7CisKKwlzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlCSpwZGV2OworCXN0cnVjdCByZXNldF9jb250cm9sCSpyZXNldDsKKwlzdHJ1Y3QgY2xrCQkqY2xvY2s7CisJdm9pZCBfX2lvbWVtCQkqcmVnczsKKworCXNwaW5sb2NrX3QJCWxvY2s7CisKKwlzdHJ1Y3QgY2xrCQkqZW1jX2Nsb2NrOworCXVuc2lnbmVkIGxvbmcJCW1heF9mcmVxOworCXVuc2lnbmVkIGxvbmcJCWN1cl9mcmVxOworCXN0cnVjdCBub3RpZmllcl9ibG9jawlyYXRlX2NoYW5nZV9uYjsKKworCXN0cnVjdCB0ZWdyYV9kZXZmcmVxX2RldmljZSBkZXZpY2VzW0FSUkFZX1NJWkUoYWN0bW9uX2RldmljZV9jb25maWdzKV07Cit9OworCitzdHJ1Y3QgdGVncmFfYWN0bW9uX2VtY19yYXRpbyB7CisJdW5zaWduZWQgbG9uZyBjcHVfZnJlcTsKKwl1bnNpZ25lZCBsb25nIGVtY19mcmVxOworfTsKKworc3RhdGljIHN0cnVjdCB0ZWdyYV9hY3Rtb25fZW1jX3JhdGlvIGFjdG1vbl9lbWNfcmF0aW9zW10gPSB7CisJeyAxNDAwMDAwLCBVTE9OR19NQVggfSwKKwl7IDEyMDAwMDAsICAgIDc1MDAwMCB9LAorCXsgMTEwMDAwMCwgICAgNjAwMDAwIH0sCisJeyAxMDAwMDAwLCAgICA1MDAwMDAgfSwKKwl7ICA4MDAwMDAsICAgIDM3NTAwMCB9LAorCXsgIDUwMDAwMCwgICAgMjAwMDAwIH0sCisJeyAgMjUwMDAwLCAgICAxMDAwMDAgfSwKK307CisKK3N0YXRpYyB1bnNpZ25lZCBsb25nIGRvX3BlcmNlbnQodW5zaWduZWQgbG9uZyB2YWwsIHVuc2lnbmVkIGludCBwY3QpCit7CisJcmV0dXJuIHZhbCAqIHBjdCAvIDEwMDsKK30KKworc3RhdGljIHZvaWQgdGVncmFfZGV2ZnJlcV91cGRhdGVfYXZnX3dtYXJrKHN0cnVjdCB0ZWdyYV9kZXZmcmVxX2RldmljZSAqZGV2KQoreworCXUzMiBhdmcgPSBkZXYtPmF2Z19jb3VudDsKKwl1MzIgYmFuZCA9IGRldi0+YXZnX2JhbmRfZnJlcSAqIEFDVE1PTl9TQU1QTElOR19QRVJJT0Q7CisKKwl3cml0ZWwoYXZnICsgYmFuZCwgZGV2LT5yZWdzICsgQUNUTU9OX0RFVl9BVkdfVVBQRVJfV01BUkspOworCWF2ZyA9IG1heChhdmcsIGJhbmQpOworCXdyaXRlbChhdmcgLSBiYW5kLCBkZXYtPnJlZ3MgKyBBQ1RNT05fREVWX0FWR19MT1dFUl9XTUFSSyk7Cit9CisKK3N0YXRpYyB2b2lkIHRlZ3JhX2RldmZyZXFfdXBkYXRlX3dtYXJrKHN0cnVjdCB0ZWdyYV9kZXZmcmVxICp0ZWdyYSwKKwkJCQkgICAgICAgc3RydWN0IHRlZ3JhX2RldmZyZXFfZGV2aWNlICpkZXYpCit7CisJdTMyIHZhbCA9IHRlZ3JhLT5jdXJfZnJlcSAqIEFDVE1PTl9TQU1QTElOR19QRVJJT0Q7CisKKwl3cml0ZWwoZG9fcGVyY2VudCh2YWwsIGRldi0+Y29uZmlnLT5ib29zdF91cF90aHJlc2hvbGQpLAorCSAgICAgICBkZXYtPnJlZ3MgKyBBQ1RNT05fREVWX1VQUEVSX1dNQVJLKTsKKworCXdyaXRlbChkb19wZXJjZW50KHZhbCwgZGV2LT5jb25maWctPmJvb3N0X2Rvd25fdGhyZXNob2xkKSwKKwkgICAgICAgZGV2LT5yZWdzICsgQUNUTU9OX0RFVl9MT1dFUl9XTUFSSyk7Cit9CisKK3N0YXRpYyB2b2lkIGFjdG1vbl93cml0ZV9iYXJyaWVyKHN0cnVjdCB0ZWdyYV9kZXZmcmVxICp0ZWdyYSkKK3sKKwkvKiBlbnN1cmUgdGhlIHVwZGF0ZSBoYXMgcmVhY2hlZCB0aGUgQUNUTU9OICovCisJd21iKCk7CisJcmVhZGwodGVncmEtPnJlZ3MgKyBBQ1RNT05fR0xCX1NUQVRVUyk7Cit9CisKK3N0YXRpYyBpcnFyZXR1cm5fdCBhY3Rtb25faXNyKGludCBpcnEsIHZvaWQgKmRhdGEpCit7CisJc3RydWN0IHRlZ3JhX2RldmZyZXEgKnRlZ3JhID0gZGF0YTsKKwlzdHJ1Y3QgdGVncmFfZGV2ZnJlcV9kZXZpY2UgKmRldiA9IE5VTEw7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwl1MzIgdmFsOworCXVuc2lnbmVkIGludCBpOworCisJdmFsID0gcmVhZGwodGVncmEtPnJlZ3MgKyBBQ1RNT05fR0xCX1NUQVRVUyk7CisKKwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRSh0ZWdyYS0+ZGV2aWNlcyk7IGkrKykgeworCQlpZiAodmFsICYgdGVncmEtPmRldmljZXNbaV0uY29uZmlnLT5pcnFfbWFzaykgeworCQkJZGV2ID0gdGVncmEtPmRldmljZXMgKyBpOworCQkJYnJlYWs7CisJCX0KKwl9CisKKwlpZiAoIWRldikKKwkJcmV0dXJuIElSUV9OT05FOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJnRlZ3JhLT5sb2NrLCBmbGFncyk7CisKKwlkZXYtPmF2Z19jb3VudCA9IHJlYWRsKGRldi0+cmVncyArIEFDVE1PTl9ERVZfQVZHX0NPVU5UKTsKKwl0ZWdyYV9kZXZmcmVxX3VwZGF0ZV9hdmdfd21hcmsoZGV2KTsKKworCXZhbCA9IHJlYWRsKGRldi0+cmVncyArIEFDVE1PTl9ERVZfSU5UUl9TVEFUVVMpOworCWlmICh2YWwgJiBBQ1RNT05fREVWX0lOVFJfQ09OU0VDVVRJVkVfVVBQRVIpIHsKKwkJdmFsID0gcmVhZGwoZGV2LT5yZWdzICsgQUNUTU9OX0RFVl9DVFJMKSB8CisJCQlBQ1RNT05fREVWX0NUUkxfQ09OU0VDVVRJVkVfQUJPVkVfV01BUktfRU4gfAorCQkJQUNUTU9OX0RFVl9DVFJMX0NPTlNFQ1VUSVZFX0JFTE9XX1dNQVJLX0VOOworCisJCS8qCisJCSAqIG5ld19ib29zdCA9IG1pbihvbGRfYm9vc3QgKiB1cF9jb2VmICsgc3RlcCwgbWF4X2ZyZXEpCisJCSAqLworCQlkZXYtPmJvb3N0X2ZyZXEgPSBkb19wZXJjZW50KGRldi0+Ym9vc3RfZnJlcSwKKwkJCQkJICAgICBkZXYtPmNvbmZpZy0+Ym9vc3RfdXBfY29lZmYpOworCQlkZXYtPmJvb3N0X2ZyZXEgKz0gQUNUTU9OX0JPT1NUX0ZSRVFfU1RFUDsKKwkJaWYgKGRldi0+Ym9vc3RfZnJlcSA+PSB0ZWdyYS0+bWF4X2ZyZXEpIHsKKwkJCWRldi0+Ym9vc3RfZnJlcSA9IHRlZ3JhLT5tYXhfZnJlcTsKKwkJCXZhbCAmPSB+QUNUTU9OX0RFVl9DVFJMX0NPTlNFQ1VUSVZFX0FCT1ZFX1dNQVJLX0VOOworCQl9CisJCXdyaXRlbCh2YWwsIGRldi0+cmVncyArIEFDVE1PTl9ERVZfQ1RSTCk7CisJfSBlbHNlIGlmICh2YWwgJiBBQ1RNT05fREVWX0lOVFJfQ09OU0VDVVRJVkVfTE9XRVIpIHsKKwkJdmFsID0gcmVhZGwoZGV2LT5yZWdzICsgQUNUTU9OX0RFVl9DVFJMKSB8CisJCQlBQ1RNT05fREVWX0NUUkxfQ09OU0VDVVRJVkVfQUJPVkVfV01BUktfRU4gfAorCQkJQUNUTU9OX0RFVl9DVFJMX0NPTlNFQ1VUSVZFX0JFTE9XX1dNQVJLX0VOOworCisJCS8qCisJCSAqIG5ld19ib29zdCA9IG9sZF9ib29zdCAqIGRvd25fY29lZgorCQkgKiBvciAwIGlmIChvbGRfYm9vc3QgKiBkb3duX2NvZWYgPCBzdGVwIC8gMikKKwkJICovCisJCWRldi0+Ym9vc3RfZnJlcSA9IGRvX3BlcmNlbnQoZGV2LT5ib29zdF9mcmVxLAorCQkJCQkgICAgIGRldi0+Y29uZmlnLT5ib29zdF9kb3duX2NvZWZmKTsKKwkJaWYgKGRldi0+Ym9vc3RfZnJlcSA8IChBQ1RNT05fQk9PU1RfRlJFUV9TVEVQID4+IDEpKSB7CisJCQlkZXYtPmJvb3N0X2ZyZXEgPSAwOworCQkJdmFsICY9IH5BQ1RNT05fREVWX0NUUkxfQ09OU0VDVVRJVkVfQkVMT1dfV01BUktfRU47CisJCX0KKwkJd3JpdGVsKHZhbCwgZGV2LT5yZWdzICsgQUNUTU9OX0RFVl9DVFJMKTsKKwl9CisKKwlpZiAoZGV2LT5jb25maWctPmF2Z19kZXBlbmRlbmN5X3RocmVzaG9sZCkgeworCQl2YWwgPSByZWFkbChkZXYtPnJlZ3MgKyBBQ1RNT05fREVWX0NUUkwpOworCQlpZiAoZGV2LT5hdmdfY291bnQgPj0gZGV2LT5jb25maWctPmF2Z19kZXBlbmRlbmN5X3RocmVzaG9sZCkKKwkJCXZhbCB8PSBBQ1RNT05fREVWX0NUUkxfQ09OU0VDVVRJVkVfQkVMT1dfV01BUktfRU47CisJCWVsc2UgaWYgKGRldi0+Ym9vc3RfZnJlcSA9PSAwKQorCQkJdmFsICY9IH5BQ1RNT05fREVWX0NUUkxfQ09OU0VDVVRJVkVfQkVMT1dfV01BUktfRU47CisJCXdyaXRlbCh2YWwsIGRldi0+cmVncyArIEFDVE1PTl9ERVZfQ1RSTCk7CisJfQorCisJd3JpdGVsKEFDVE1PTl9JTlRSX1NUQVRVU19DTEVBUiwgZGV2LT5yZWdzICsgQUNUTU9OX0RFVl9JTlRSX1NUQVRVUyk7CisKKwlhY3Rtb25fd3JpdGVfYmFycmllcih0ZWdyYSk7CisKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZ0ZWdyYS0+bG9jaywgZmxhZ3MpOworCisJcmV0dXJuIElSUV9XQUtFX1RIUkVBRDsKK30KKworc3RhdGljIHVuc2lnbmVkIGxvbmcgYWN0bW9uX2NwdV90b19lbWNfcmF0ZShzdHJ1Y3QgdGVncmFfZGV2ZnJlcSAqdGVncmEsCisJCQkJCSAgICB1bnNpZ25lZCBsb25nIGNwdV9mcmVxKQoreworCXVuc2lnbmVkIGludCBpOworCXN0cnVjdCB0ZWdyYV9hY3Rtb25fZW1jX3JhdGlvICpyYXRpbyA9IGFjdG1vbl9lbWNfcmF0aW9zOworCisJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUoYWN0bW9uX2VtY19yYXRpb3MpOyBpKyssIHJhdGlvKyspIHsKKwkJaWYgKGNwdV9mcmVxID49IHJhdGlvLT5jcHVfZnJlcSkgeworCQkJaWYgKHJhdGlvLT5lbWNfZnJlcSA+PSB0ZWdyYS0+bWF4X2ZyZXEpCisJCQkJcmV0dXJuIHRlZ3JhLT5tYXhfZnJlcTsKKwkJCWVsc2UKKwkJCQlyZXR1cm4gcmF0aW8tPmVtY19mcmVxOworCQl9CisJfQorCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIGFjdG1vbl91cGRhdGVfdGFyZ2V0KHN0cnVjdCB0ZWdyYV9kZXZmcmVxICp0ZWdyYSwKKwkJCQkgc3RydWN0IHRlZ3JhX2RldmZyZXFfZGV2aWNlICpkZXYpCit7CisJdW5zaWduZWQgbG9uZyBjcHVfZnJlcSA9IDA7CisJdW5zaWduZWQgbG9uZyBzdGF0aWNfY3B1X2VtY19mcmVxID0gMDsKKwl1bnNpZ25lZCBpbnQgYXZnX3N1c3RhaW5fY29lZjsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJaWYgKGRldi0+Y29uZmlnLT5hdmdfZGVwZW5kZW5jeV90aHJlc2hvbGQpIHsKKwkJY3B1X2ZyZXEgPSBjcHVmcmVxX2dldCgwKTsKKwkJc3RhdGljX2NwdV9lbWNfZnJlcSA9IGFjdG1vbl9jcHVfdG9fZW1jX3JhdGUodGVncmEsIGNwdV9mcmVxKTsKKwl9CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmdGVncmEtPmxvY2ssIGZsYWdzKTsKKworCWRldi0+dGFyZ2V0X2ZyZXEgPSBkZXYtPmF2Z19jb3VudCAvIEFDVE1PTl9TQU1QTElOR19QRVJJT0Q7CisJYXZnX3N1c3RhaW5fY29lZiA9IDEwMCAqIDEwMCAvIGRldi0+Y29uZmlnLT5ib29zdF91cF90aHJlc2hvbGQ7CisJZGV2LT50YXJnZXRfZnJlcSA9IGRvX3BlcmNlbnQoZGV2LT50YXJnZXRfZnJlcSwgYXZnX3N1c3RhaW5fY29lZik7CisJZGV2LT50YXJnZXRfZnJlcSArPSBkZXYtPmJvb3N0X2ZyZXE7CisKKwlpZiAoZGV2LT5hdmdfY291bnQgPj0gZGV2LT5jb25maWctPmF2Z19kZXBlbmRlbmN5X3RocmVzaG9sZCkKKwkJZGV2LT50YXJnZXRfZnJlcSA9IG1heChkZXYtPnRhcmdldF9mcmVxLCBzdGF0aWNfY3B1X2VtY19mcmVxKTsKKworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnRlZ3JhLT5sb2NrLCBmbGFncyk7Cit9CisKK3N0YXRpYyBpcnFyZXR1cm5fdCBhY3Rtb25fdGhyZWFkX2lzcihpbnQgaXJxLCB2b2lkICpkYXRhKQoreworCXN0cnVjdCB0ZWdyYV9kZXZmcmVxICp0ZWdyYSA9IGRhdGE7CisKKwltdXRleF9sb2NrKCZ0ZWdyYS0+ZGV2ZnJlcS0+bG9jayk7CisJdXBkYXRlX2RldmZyZXEodGVncmEtPmRldmZyZXEpOworCW11dGV4X3VubG9jaygmdGVncmEtPmRldmZyZXEtPmxvY2spOworCisJcmV0dXJuIElSUV9IQU5ETEVEOworfQorCitzdGF0aWMgaW50IHRlZ3JhX2FjdG1vbl9yYXRlX25vdGlmeV9jYihzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sgKm5iLAorCQkJCSAgICAgICB1bnNpZ25lZCBsb25nIGFjdGlvbiwgdm9pZCAqcHRyKQoreworCXN0cnVjdCBjbGtfbm90aWZpZXJfZGF0YSAqZGF0YSA9IHB0cjsKKwlzdHJ1Y3QgdGVncmFfZGV2ZnJlcSAqdGVncmEgPSBjb250YWluZXJfb2YobmIsIHN0cnVjdCB0ZWdyYV9kZXZmcmVxLAorCQkJCQkJICAgcmF0ZV9jaGFuZ2VfbmIpOworCXVuc2lnbmVkIGludCBpOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmdGVncmEtPmxvY2ssIGZsYWdzKTsKKworCXN3aXRjaCAoYWN0aW9uKSB7CisJY2FzZSBQT1NUX1JBVEVfQ0hBTkdFOgorCQl0ZWdyYS0+Y3VyX2ZyZXEgPSBkYXRhLT5uZXdfcmF0ZSAvIEtIWjsKKworCQlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRSh0ZWdyYS0+ZGV2aWNlcyk7IGkrKykKKwkJCXRlZ3JhX2RldmZyZXFfdXBkYXRlX3dtYXJrKHRlZ3JhLCB0ZWdyYS0+ZGV2aWNlcyArIGkpOworCisJCWFjdG1vbl93cml0ZV9iYXJyaWVyKHRlZ3JhKTsKKwkJYnJlYWs7CisJY2FzZSBQUkVfUkFURV9DSEFOR0U6CisJCS8qIGZhbGwgdGhyb3VnaCAqLworCWNhc2UgQUJPUlRfUkFURV9DSEFOR0U6CisJCWJyZWFrOworCX07CisKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZ0ZWdyYS0+bG9jaywgZmxhZ3MpOworCisJcmV0dXJuIE5PVElGWV9PSzsKK30KKworc3RhdGljIHZvaWQgdGVncmFfYWN0bW9uX2NvbmZpZ3VyZV9kZXZpY2Uoc3RydWN0IHRlZ3JhX2RldmZyZXEgKnRlZ3JhLAorCQkJCQkgIHN0cnVjdCB0ZWdyYV9kZXZmcmVxX2RldmljZSAqZGV2KQoreworCXUzMiB2YWw7CisKKwlkZXYtPmF2Z19iYW5kX2ZyZXEgPSB0ZWdyYS0+bWF4X2ZyZXEgKiBBQ1RNT05fREVGQVVMVF9BVkdfQkFORCAvIEtIWjsKKwlkZXYtPnRhcmdldF9mcmVxID0gdGVncmEtPmN1cl9mcmVxOworCisJZGV2LT5hdmdfY291bnQgPSB0ZWdyYS0+Y3VyX2ZyZXEgKiBBQ1RNT05fU0FNUExJTkdfUEVSSU9EOworCXdyaXRlbChkZXYtPmF2Z19jb3VudCwgZGV2LT5yZWdzICsgQUNUTU9OX0RFVl9JTklUX0FWRyk7CisKKwl0ZWdyYV9kZXZmcmVxX3VwZGF0ZV9hdmdfd21hcmsoZGV2KTsKKwl0ZWdyYV9kZXZmcmVxX3VwZGF0ZV93bWFyayh0ZWdyYSwgZGV2KTsKKworCXdyaXRlbChBQ1RNT05fQ09VTlRfV0VJR0hULCBkZXYtPnJlZ3MgKyBBQ1RNT05fREVWX0NPVU5UX1dFSUdIVCk7CisJd3JpdGVsKEFDVE1PTl9JTlRSX1NUQVRVU19DTEVBUiwgZGV2LT5yZWdzICsgQUNUTU9OX0RFVl9JTlRSX1NUQVRVUyk7CisKKwl2YWwgPSAwOworCXZhbCB8PSBBQ1RNT05fREVWX0NUUkxfRU5CX1BFUklPRElDIHwKKwkgICAgICAgQUNUTU9OX0RFVl9DVFJMX0FWR19BQk9WRV9XTUFSS19FTiB8CisJICAgICAgIEFDVE1PTl9ERVZfQ1RSTF9BVkdfQkVMT1dfV01BUktfRU47CisJdmFsIHw9IChBQ1RNT05fQVZFUkFHRV9XSU5ET1dfTE9HMiAtIDEpCisJCTw8IEFDVE1PTl9ERVZfQ1RSTF9LX1ZBTF9TSElGVDsKKwl2YWwgfD0gKEFDVE1PTl9CRUxPV19XTUFSS19XSU5ET1cgLSAxKQorCQk8PCBBQ1RNT05fREVWX0NUUkxfQ09OU0VDVVRJVkVfQkVMT1dfV01BUktfTlVNX1NISUZUOworCXZhbCB8PSAoQUNUTU9OX0FCT1ZFX1dNQVJLX1dJTkRPVyAtIDEpCisJCTw8IEFDVE1PTl9ERVZfQ1RSTF9DT05TRUNVVElWRV9BQk9WRV9XTUFSS19OVU1fU0hJRlQ7CisJdmFsIHw9IEFDVE1PTl9ERVZfQ1RSTF9DT05TRUNVVElWRV9CRUxPV19XTUFSS19FTiB8CisJICAgICAgIEFDVE1PTl9ERVZfQ1RSTF9DT05TRUNVVElWRV9BQk9WRV9XTUFSS19FTjsKKworCXdyaXRlbCh2YWwsIGRldi0+cmVncyArIEFDVE1PTl9ERVZfQ1RSTCk7CisKKwlhY3Rtb25fd3JpdGVfYmFycmllcih0ZWdyYSk7CisKKwl2YWwgPSByZWFkbChkZXYtPnJlZ3MgKyBBQ1RNT05fREVWX0NUUkwpOworCXZhbCB8PSBBQ1RNT05fREVWX0NUUkxfRU5COworCXdyaXRlbCh2YWwsIGRldi0+cmVncyArIEFDVE1PTl9ERVZfQ1RSTCk7CisKKwlhY3Rtb25fd3JpdGVfYmFycmllcih0ZWdyYSk7Cit9CisKK3N0YXRpYyBpbnQgdGVncmFfZGV2ZnJlcV9zdXNwZW5kKHN0cnVjdCBkZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2OworCXN0cnVjdCB0ZWdyYV9kZXZmcmVxICp0ZWdyYTsKKwlzdHJ1Y3QgdGVncmFfZGV2ZnJlcV9kZXZpY2UgKmFjdG1vbl9kZXY7CisJdW5zaWduZWQgaW50IGk7CisJdTMyIHZhbDsKKworCXBkZXYgPSBjb250YWluZXJfb2YoZGV2LCBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlLCBkZXYpOworCXRlZ3JhID0gcGxhdGZvcm1fZ2V0X2RydmRhdGEocGRldik7CisKKwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRSh0ZWdyYS0+ZGV2aWNlcyk7IGkrKykgeworCQlhY3Rtb25fZGV2ID0gJnRlZ3JhLT5kZXZpY2VzW2ldOworCisJCXZhbCA9IHJlYWRsKGFjdG1vbl9kZXYtPnJlZ3MgKyBBQ1RNT05fREVWX0NUUkwpOworCQl2YWwgJj0gfkFDVE1PTl9ERVZfQ1RSTF9FTkI7CisJCXdyaXRlbCh2YWwsIGFjdG1vbl9kZXYtPnJlZ3MgKyBBQ1RNT05fREVWX0NUUkwpOworCisJCXdyaXRlbChBQ1RNT05fSU5UUl9TVEFUVVNfQ0xFQVIsCisJCSAgICAgICBhY3Rtb25fZGV2LT5yZWdzICsgQUNUTU9OX0RFVl9JTlRSX1NUQVRVUyk7CisKKwkJYWN0bW9uX3dyaXRlX2JhcnJpZXIodGVncmEpOworCX0KKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IHRlZ3JhX2RldmZyZXFfcmVzdW1lKHN0cnVjdCBkZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2OworCXN0cnVjdCB0ZWdyYV9kZXZmcmVxICp0ZWdyYTsKKwlzdHJ1Y3QgdGVncmFfZGV2ZnJlcV9kZXZpY2UgKmFjdG1vbl9kZXY7CisJdW5zaWduZWQgaW50IGk7CisKKwlwZGV2ID0gY29udGFpbmVyX29mKGRldiwgc3RydWN0IHBsYXRmb3JtX2RldmljZSwgZGV2KTsKKwl0ZWdyYSA9IHBsYXRmb3JtX2dldF9kcnZkYXRhKHBkZXYpOworCisJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUodGVncmEtPmRldmljZXMpOyBpKyspIHsKKwkJYWN0bW9uX2RldiA9ICZ0ZWdyYS0+ZGV2aWNlc1tpXTsKKworCQl0ZWdyYV9hY3Rtb25fY29uZmlndXJlX2RldmljZSh0ZWdyYSwgYWN0bW9uX2Rldik7CisJfQorCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgdGVncmFfZGV2ZnJlcV90YXJnZXQoc3RydWN0IGRldmljZSAqZGV2LCB1bnNpZ25lZCBsb25nICpmcmVxLAorCQkJCXUzMiBmbGFncykKK3sKKwlzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2OworCXN0cnVjdCB0ZWdyYV9kZXZmcmVxICp0ZWdyYTsKKwlzdHJ1Y3QgZGV2X3BtX29wcCAqb3BwOworCXVuc2lnbmVkIGxvbmcgcmF0ZSA9ICpmcmVxICogS0haOworCisJcGRldiA9IGNvbnRhaW5lcl9vZihkZXYsIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UsIGRldik7CisJdGVncmEgPSBwbGF0Zm9ybV9nZXRfZHJ2ZGF0YShwZGV2KTsKKworCXJjdV9yZWFkX2xvY2soKTsKKwlvcHAgPSBkZXZmcmVxX3JlY29tbWVuZGVkX29wcChkZXYsICZyYXRlLCBmbGFncyk7CisJaWYgKElTX0VSUihvcHApKSB7CisJCXJjdV9yZWFkX3VubG9jaygpOworCQlkZXZfZXJyKGRldiwgIkZhaWxlZCB0byBmaW5kIG9wcCBmb3IgJWx1IEtIelxuIiwgKmZyZXEpOworCQlyZXR1cm4gUFRSX0VSUihvcHApOworCX0KKwlyYXRlID0gZGV2X3BtX29wcF9nZXRfZnJlcShvcHApOworCXJjdV9yZWFkX3VubG9jaygpOworCisJLyogVE9ETzogT25jZSB3ZSBoYXZlIHBlci11c2VyIGNsayBjb25zdHJhaW50cywgc2V0IGEgZmxvb3IgKi8KKwljbGtfc2V0X3JhdGUodGVncmEtPmVtY19jbG9jaywgcmF0ZSk7CisKKwkvKiBUT0RPOiBTZXQgdm9sdGFnZSBhcyB3ZWxsICovCisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCB0ZWdyYV9kZXZmcmVxX2dldF9kZXZfc3RhdHVzKHN0cnVjdCBkZXZpY2UgKmRldiwKKwkJCQkJc3RydWN0IGRldmZyZXFfZGV2X3N0YXR1cyAqc3RhdCkKK3sKKwlzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2OworCXN0cnVjdCB0ZWdyYV9kZXZmcmVxICp0ZWdyYTsKKwlzdHJ1Y3QgdGVncmFfZGV2ZnJlcV9kZXZpY2UgKmFjdG1vbl9kZXY7CisKKwlwZGV2ID0gY29udGFpbmVyX29mKGRldiwgc3RydWN0IHBsYXRmb3JtX2RldmljZSwgZGV2KTsKKwl0ZWdyYSA9IHBsYXRmb3JtX2dldF9kcnZkYXRhKHBkZXYpOworCisJc3RhdC0+Y3VycmVudF9mcmVxdWVuY3kgPSB0ZWdyYS0+Y3VyX2ZyZXE7CisKKwkvKiBUbyBiZSB1c2VkIGJ5IHRoZSB0ZWdyYSBnb3Zlcm5vciAqLworCXN0YXQtPnByaXZhdGVfZGF0YSA9IHRlZ3JhOworCisJLyogVGhlIGJlbG93IGFyZSB0byBiZSB1c2VkIGJ5IHRoZSBvdGhlciBnb3Zlcm5vcnMgKi8KKworCWFjdG1vbl9kZXYgPSAmdGVncmEtPmRldmljZXNbTUNBTExdOworCisJLyogTnVtYmVyIG9mIGN5Y2xlcyBzcGVudCBvbiBtZW1vcnkgYWNjZXNzICovCisJc3RhdC0+YnVzeV90aW1lID0gYWN0bW9uX2Rldi0+YXZnX2NvdW50OworCisJLyogVGhlIGJ1cyBjYW4gYmUgY29uc2lkZXJlZCB0byBiZSBzYXR1cmF0ZWQgd2F5IGJlZm9yZSAxMDAlICovCisJc3RhdC0+YnVzeV90aW1lICo9IDEwMCAvIEJVU19TQVRVUkFUSU9OX1JBVElPOworCisJLyogTnVtYmVyIG9mIGN5Y2xlcyBpbiBhIHNhbXBsaW5nIHBlcmlvZCAqLworCXN0YXQtPnRvdGFsX3RpbWUgPSBBQ1RNT05fU0FNUExJTkdfUEVSSU9EICogdGVncmEtPmN1cl9mcmVxOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgdGVncmFfZGV2ZnJlcV9nZXRfdGFyZ2V0KHN0cnVjdCBkZXZmcmVxICpkZXZmcmVxLAorCQkJCSAgICB1bnNpZ25lZCBsb25nICpmcmVxKQoreworCXN0cnVjdCBkZXZmcmVxX2Rldl9zdGF0dXMgc3RhdDsKKwlzdHJ1Y3QgdGVncmFfZGV2ZnJlcSAqdGVncmE7CisJc3RydWN0IHRlZ3JhX2RldmZyZXFfZGV2aWNlICpkZXY7CisJdW5zaWduZWQgbG9uZyB0YXJnZXRfZnJlcSA9IDA7CisJdW5zaWduZWQgaW50IGk7CisJaW50IGVycjsKKworCWVyciA9IGRldmZyZXEtPnByb2ZpbGUtPmdldF9kZXZfc3RhdHVzKGRldmZyZXEtPmRldi5wYXJlbnQsICZzdGF0KTsKKwlpZiAoZXJyKQorCQlyZXR1cm4gZXJyOworCisJdGVncmEgPSBzdGF0LnByaXZhdGVfZGF0YTsKKworCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKHRlZ3JhLT5kZXZpY2VzKTsgaSsrKSB7CisJCWRldiA9ICZ0ZWdyYS0+ZGV2aWNlc1tpXTsKKworCQlhY3Rtb25fdXBkYXRlX3RhcmdldCh0ZWdyYSwgZGV2KTsKKworCQl0YXJnZXRfZnJlcSA9IG1heCh0YXJnZXRfZnJlcSwgZGV2LT50YXJnZXRfZnJlcSk7CisJfQorCisJKmZyZXEgPSB0YXJnZXRfZnJlcTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IHRlZ3JhX2RldmZyZXFfZXZlbnRfaGFuZGxlcihzdHJ1Y3QgZGV2ZnJlcSAqZGV2ZnJlcSwKKwkJCQkgICAgICAgdW5zaWduZWQgaW50IGV2ZW50LCB2b2lkICpkYXRhKQoreworCXJldHVybiAwOworfQorCitzdGF0aWMgc3RydWN0IGRldmZyZXFfZ292ZXJub3IgdGVncmFfZGV2ZnJlcV9nb3Zlcm5vciA9IHsKKwkubmFtZSA9ICJ0ZWdyYSIsCisJLmdldF90YXJnZXRfZnJlcSA9IHRlZ3JhX2RldmZyZXFfZ2V0X3RhcmdldCwKKwkuZXZlbnRfaGFuZGxlciA9IHRlZ3JhX2RldmZyZXFfZXZlbnRfaGFuZGxlciwKK307CisKK3N0YXRpYyBzdHJ1Y3QgZGV2ZnJlcV9kZXZfcHJvZmlsZSB0ZWdyYV9kZXZmcmVxX3Byb2ZpbGUgPSB7CisJLnBvbGxpbmdfbXMJPSAwLAorCS50YXJnZXQJCT0gdGVncmFfZGV2ZnJlcV90YXJnZXQsCisJLmdldF9kZXZfc3RhdHVzCT0gdGVncmFfZGV2ZnJlcV9nZXRfZGV2X3N0YXR1cywKK307CisKK3N0YXRpYyBpbnQgdGVncmFfZGV2ZnJlcV9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQoreworCXN0cnVjdCB0ZWdyYV9kZXZmcmVxICp0ZWdyYTsKKwlzdHJ1Y3QgdGVncmFfZGV2ZnJlcV9kZXZpY2UgKmRldjsKKwlzdHJ1Y3QgcmVzb3VyY2UgKnJlczsKKwl1bnNpZ25lZCBsb25nIG1heF9mcmVxOworCXVuc2lnbmVkIGludCBpOworCWludCBpcnE7CisJaW50IGVycjsKKworCXRlZ3JhID0gZGV2bV9remFsbG9jKCZwZGV2LT5kZXYsIHNpemVvZigqdGVncmEpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIXRlZ3JhKQorCQlyZXR1cm4gLUVOT01FTTsKKworCXNwaW5fbG9ja19pbml0KCZ0ZWdyYS0+bG9jayk7CisKKwlyZXMgPSBwbGF0Zm9ybV9nZXRfcmVzb3VyY2UocGRldiwgSU9SRVNPVVJDRV9NRU0sIDApOworCWlmICghcmVzKSB7CisJCWRldl9lcnIoJnBkZXYtPmRldiwgIkZhaWxlZCB0byBnZXQgcmVncyByZXNvdXJjZVxuIik7CisJCXJldHVybiAtRU5PREVWOworCX0KKworCXRlZ3JhLT5yZWdzID0gZGV2bV9pb3JlbWFwX3Jlc291cmNlKCZwZGV2LT5kZXYsIHJlcyk7CisJaWYgKElTX0VSUih0ZWdyYS0+cmVncykpIHsKKwkJZGV2X2VycigmcGRldi0+ZGV2LCAiRmFpbGVkIHRvIGdldCBJTyBtZW1vcnlcbiIpOworCQlyZXR1cm4gUFRSX0VSUih0ZWdyYS0+cmVncyk7CisJfQorCisJdGVncmEtPnJlc2V0ID0gZGV2bV9yZXNldF9jb250cm9sX2dldCgmcGRldi0+ZGV2LCAiYWN0bW9uIik7CisJaWYgKElTX0VSUih0ZWdyYS0+cmVzZXQpKSB7CisJCWRldl9lcnIoJnBkZXYtPmRldiwgIkZhaWxlZCB0byBnZXQgcmVzZXRcbiIpOworCQlyZXR1cm4gUFRSX0VSUih0ZWdyYS0+cmVzZXQpOworCX0KKworCXRlZ3JhLT5jbG9jayA9IGRldm1fY2xrX2dldCgmcGRldi0+ZGV2LCAiYWN0bW9uIik7CisJaWYgKElTX0VSUih0ZWdyYS0+Y2xvY2spKSB7CisJCWRldl9lcnIoJnBkZXYtPmRldiwgIkZhaWxlZCB0byBnZXQgYWN0bW9uIGNsb2NrXG4iKTsKKwkJcmV0dXJuIFBUUl9FUlIodGVncmEtPmNsb2NrKTsKKwl9CisKKwl0ZWdyYS0+ZW1jX2Nsb2NrID0gZGV2bV9jbGtfZ2V0KCZwZGV2LT5kZXYsICJlbWMiKTsKKwlpZiAoSVNfRVJSKHRlZ3JhLT5lbWNfY2xvY2spKSB7CisJCWRldl9lcnIoJnBkZXYtPmRldiwgIkZhaWxlZCB0byBnZXQgZW1jIGNsb2NrXG4iKTsKKwkJcmV0dXJuIFBUUl9FUlIodGVncmEtPmVtY19jbG9jayk7CisJfQorCisJZXJyID0gb2ZfaW5pdF9vcHBfdGFibGUoJnBkZXYtPmRldik7CisJaWYgKGVycikgeworCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJGYWlsZWQgdG8gaW5pdCBvcGVyYXRpbmcgcG9pbnQgdGFibGVcbiIpOworCQlyZXR1cm4gZXJyOworCX0KKworCXRlZ3JhLT5yYXRlX2NoYW5nZV9uYi5ub3RpZmllcl9jYWxsID0gdGVncmFfYWN0bW9uX3JhdGVfbm90aWZ5X2NiOworCWVyciA9IGNsa19ub3RpZmllcl9yZWdpc3Rlcih0ZWdyYS0+ZW1jX2Nsb2NrLCAmdGVncmEtPnJhdGVfY2hhbmdlX25iKTsKKwlpZiAoZXJyKSB7CisJCWRldl9lcnIoJnBkZXYtPmRldiwKKwkJCSJGYWlsZWQgdG8gcmVnaXN0ZXIgcmF0ZSBjaGFuZ2Ugbm90aWZpZXJcbiIpOworCQlyZXR1cm4gZXJyOworCX0KKworCXJlc2V0X2NvbnRyb2xfYXNzZXJ0KHRlZ3JhLT5yZXNldCk7CisKKwllcnIgPSBjbGtfcHJlcGFyZV9lbmFibGUodGVncmEtPmNsb2NrKTsKKwlpZiAoZXJyKSB7CisJCXJlc2V0X2NvbnRyb2xfZGVhc3NlcnQodGVncmEtPnJlc2V0KTsKKwkJcmV0dXJuIGVycjsKKwl9CisKKwlyZXNldF9jb250cm9sX2RlYXNzZXJ0KHRlZ3JhLT5yZXNldCk7CisKKwltYXhfZnJlcSA9IGNsa19yb3VuZF9yYXRlKHRlZ3JhLT5lbWNfY2xvY2ssIFVMT05HX01BWCk7CisJdGVncmEtPm1heF9mcmVxID0gbWF4X2ZyZXEgLyBLSFo7CisKKwljbGtfc2V0X3JhdGUodGVncmEtPmVtY19jbG9jaywgbWF4X2ZyZXEpOworCisJdGVncmEtPmN1cl9mcmVxID0gY2xrX2dldF9yYXRlKHRlZ3JhLT5lbWNfY2xvY2spIC8gS0haOworCisJd3JpdGVsKEFDVE1PTl9TQU1QTElOR19QRVJJT0QgLSAxLAorCSAgICAgICB0ZWdyYS0+cmVncyArIEFDVE1PTl9HTEJfUEVSSU9EX0NUUkwpOworCisJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUoYWN0bW9uX2RldmljZV9jb25maWdzKTsgaSsrKSB7CisJCWRldiA9IHRlZ3JhLT5kZXZpY2VzICsgaTsKKwkJZGV2LT5jb25maWcgPSBhY3Rtb25fZGV2aWNlX2NvbmZpZ3MgKyBpOworCQlkZXYtPnJlZ3MgPSB0ZWdyYS0+cmVncyArIGRldi0+Y29uZmlnLT5vZmZzZXQ7CisKKwkJdGVncmFfYWN0bW9uX2NvbmZpZ3VyZV9kZXZpY2UodGVncmEsIHRlZ3JhLT5kZXZpY2VzICsgaSk7CisJfQorCisJZXJyID0gZGV2ZnJlcV9hZGRfZ292ZXJub3IoJnRlZ3JhX2RldmZyZXFfZ292ZXJub3IpOworCWlmIChlcnIpIHsKKwkJZGV2X2VycigmcGRldi0+ZGV2LCAiRmFpbGVkIHRvIGFkZCBnb3Zlcm5vclxuIik7CisJCXJldHVybiBlcnI7CisJfQorCisJdGVncmFfZGV2ZnJlcV9wcm9maWxlLmluaXRpYWxfZnJlcSA9IGNsa19nZXRfcmF0ZSh0ZWdyYS0+ZW1jX2Nsb2NrKTsKKwl0ZWdyYS0+ZGV2ZnJlcSA9IGRldm1fZGV2ZnJlcV9hZGRfZGV2aWNlKCZwZGV2LT5kZXYsCisJCQkJCQkgJnRlZ3JhX2RldmZyZXFfcHJvZmlsZSwKKwkJCQkJCSAidGVncmEiLAorCQkJCQkJIE5VTEwpOworCisJaXJxID0gcGxhdGZvcm1fZ2V0X2lycShwZGV2LCAwKTsKKwllcnIgPSBkZXZtX3JlcXVlc3RfdGhyZWFkZWRfaXJxKCZwZGV2LT5kZXYsIGlycSwgYWN0bW9uX2lzciwKKwkJCQkJYWN0bW9uX3RocmVhZF9pc3IsIElSUUZfU0hBUkVELAorCQkJCQkidGVncmEtZGV2ZnJlcSIsIHRlZ3JhKTsKKwlpZiAoZXJyKSB7CisJCWRldl9lcnIoJnBkZXYtPmRldiwgIkludGVycnVwdCByZXF1ZXN0IGZhaWxlZFxuIik7CisJCXJldHVybiBlcnI7CisJfQorCisJcGxhdGZvcm1fc2V0X2RydmRhdGEocGRldiwgdGVncmEpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgdGVncmFfZGV2ZnJlcV9yZW1vdmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKK3sKKwlzdHJ1Y3QgdGVncmFfZGV2ZnJlcSAqdGVncmEgPSBwbGF0Zm9ybV9nZXRfZHJ2ZGF0YShwZGV2KTsKKworCWNsa19ub3RpZmllcl91bnJlZ2lzdGVyKHRlZ3JhLT5lbWNfY2xvY2ssICZ0ZWdyYS0+cmF0ZV9jaGFuZ2VfbmIpOworCisJY2xrX2Rpc2FibGVfdW5wcmVwYXJlKHRlZ3JhLT5jbG9jayk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIFNJTVBMRV9ERVZfUE1fT1BTKHRlZ3JhX2RldmZyZXFfcG1fb3BzLAorCQkJIHRlZ3JhX2RldmZyZXFfc3VzcGVuZCwKKwkJCSB0ZWdyYV9kZXZmcmVxX3Jlc3VtZSk7CisKK3N0YXRpYyBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkIHRlZ3JhX2RldmZyZXFfb2ZfbWF0Y2hbXSA9IHsKKwl7IC5jb21wYXRpYmxlID0gIm52aWRpYSx0ZWdyYTEyNC1hY3Rtb24iIH0sCisJeyB9LAorfTsKKworc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kcml2ZXIgdGVncmFfZGV2ZnJlcV9kcml2ZXIgPSB7CisJLnByb2JlCT0gdGVncmFfZGV2ZnJlcV9wcm9iZSwKKwkucmVtb3ZlCT0gdGVncmFfZGV2ZnJlcV9yZW1vdmUsCisJLmRyaXZlciA9IHsKKwkJLm5hbWUJCT0gInRlZ3JhLWRldmZyZXEiLAorCQkub3duZXIJCT0gVEhJU19NT0RVTEUsCisJCS5vZl9tYXRjaF90YWJsZSA9IHRlZ3JhX2RldmZyZXFfb2ZfbWF0Y2gsCisJCS5wbQkJPSAmdGVncmFfZGV2ZnJlcV9wbV9vcHMsCisJfSwKK307Cittb2R1bGVfcGxhdGZvcm1fZHJpdmVyKHRlZ3JhX2RldmZyZXFfZHJpdmVyKTsKKworTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOworTU9EVUxFX0RFU0NSSVBUSU9OKCJUZWdyYSBkZXZmcmVxIGRyaXZlciIpOworTU9EVUxFX0FVVEhPUigiVG9tZXUgVml6b3NvIDx0b21ldS52aXpvc29AY29sbGFib3JhLmNvbT4iKTsKK01PRFVMRV9ERVZJQ0VfVEFCTEUob2YsIHRlZ3JhX2RldmZyZXFfb2ZfbWF0Y2gpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9kbWEvYWNwaS1kbWEuYyBiL2RyaXZlcnMvZG1hL2FjcGktZG1hLmMKaW5kZXggZGUzNjFhMS4uNWE2MzU2NCAxMDA2NDQKLS0tIGEvZHJpdmVycy9kbWEvYWNwaS1kbWEuYworKysgYi9kcml2ZXJzL2RtYS9hY3BpLWRtYS5jCkBAIC00Myw3ICs0Myw3IEBACiB7CiAJY29uc3Qgc3RydWN0IGFjcGlfY3NydF9zaGFyZWRfaW5mbyAqc2k7CiAJc3RydWN0IGxpc3RfaGVhZCByZXNvdXJjZV9saXN0OwotCXN0cnVjdCByZXNvdXJjZV9saXN0X2VudHJ5ICpyZW50cnk7CisJc3RydWN0IHJlc291cmNlX2VudHJ5ICpyZW50cnk7CiAJcmVzb3VyY2Vfc2l6ZV90IG1lbSA9IDAsIGlycSA9IDA7CiAJaW50IHJldDsKIApAQCAtNTYsMTAgKzU2LDEwIEBACiAJCXJldHVybiAwOwogCiAJbGlzdF9mb3JfZWFjaF9lbnRyeShyZW50cnksICZyZXNvdXJjZV9saXN0LCBub2RlKSB7Ci0JCWlmIChyZXNvdXJjZV90eXBlKCZyZW50cnktPnJlcykgPT0gSU9SRVNPVVJDRV9NRU0pCi0JCQltZW0gPSByZW50cnktPnJlcy5zdGFydDsKLQkJZWxzZSBpZiAocmVzb3VyY2VfdHlwZSgmcmVudHJ5LT5yZXMpID09IElPUkVTT1VSQ0VfSVJRKQotCQkJaXJxID0gcmVudHJ5LT5yZXMuc3RhcnQ7CisJCWlmIChyZXNvdXJjZV90eXBlKHJlbnRyeS0+cmVzKSA9PSBJT1JFU09VUkNFX01FTSkKKwkJCW1lbSA9IHJlbnRyeS0+cmVzLT5zdGFydDsKKwkJZWxzZSBpZiAocmVzb3VyY2VfdHlwZShyZW50cnktPnJlcykgPT0gSU9SRVNPVVJDRV9JUlEpCisJCQlpcnEgPSByZW50cnktPnJlcy0+c3RhcnQ7CiAJfQogCiAJYWNwaV9kZXZfZnJlZV9yZXNvdXJjZV9saXN0KCZyZXNvdXJjZV9saXN0KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3Bpby9ncGlvLWNyeXN0YWxjb3ZlLmMgYi9kcml2ZXJzL2dwaW8vZ3Bpby1jcnlzdGFsY292ZS5jCmluZGV4IDU1ZDQ4MDMuLjNkOWUwOGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3Bpby9ncGlvLWNyeXN0YWxjb3ZlLmMKKysrIGIvZHJpdmVycy9ncGlvL2dwaW8tY3J5c3RhbGNvdmUuYwpAQCAtMjcyLDcgKzI3Miw3IEBACiAJZm9yIChncGlvID0gMDsgZ3BpbyA8IENSWVNUQUxDT1ZFX0dQSU9fTlVNOyBncGlvKyspIHsKIAkJaWYgKHBlbmRpbmcgJiBCSVQoZ3BpbykpIHsKIAkJCXZpcnEgPSBpcnFfZmluZF9tYXBwaW5nKGNnLT5jaGlwLmlycWRvbWFpbiwgZ3Bpbyk7Ci0JCQlnZW5lcmljX2hhbmRsZV9pcnEodmlycSk7CisJCQloYW5kbGVfbmVzdGVkX2lycSh2aXJxKTsKIAkJfQogCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncGlvL2dwaW8tbWNwMjNzMDguYyBiL2RyaXZlcnMvZ3Bpby9ncGlvLW1jcDIzczA4LmMKaW5kZXggZGE5YzMxNi4uZWVhNWQ3ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncGlvL2dwaW8tbWNwMjNzMDguYworKysgYi9kcml2ZXJzL2dwaW8vZ3Bpby1tY3AyM3MwOC5jCkBAIC04MDEsOSArODAxLDExIEBACiAJCWNsaWVudC0+aXJxID0gaXJxX29mX3BhcnNlX2FuZF9tYXAoY2xpZW50LT5kZXYub2Zfbm9kZSwgMCk7CiAJfSBlbHNlIHsKIAkJcGRhdGEgPSBkZXZfZ2V0X3BsYXRkYXRhKCZjbGllbnQtPmRldik7Ci0JCWlmICghcGRhdGEgfHwgIWdwaW9faXNfdmFsaWQocGRhdGEtPmJhc2UpKSB7Ci0JCQlkZXZfZGJnKCZjbGllbnQtPmRldiwgImludmFsaWQgcGxhdGZvcm0gZGF0YVxuIik7Ci0JCQlyZXR1cm4gLUVJTlZBTDsKKwkJaWYgKCFwZGF0YSkgeworCQkJcGRhdGEgPSBkZXZtX2t6YWxsb2MoJmNsaWVudC0+ZGV2LAorCQkJCQlzaXplb2Yoc3RydWN0IG1jcDIzczA4X3BsYXRmb3JtX2RhdGEpLAorCQkJCQlHRlBfS0VSTkVMKTsKKwkJCXBkYXRhLT5iYXNlID0gLTE7CiAJCX0KIAl9CiAKQEAgLTkyNCwxMCArOTI2LDExIEBACiAJfSBlbHNlIHsKIAkJdHlwZSA9IHNwaV9nZXRfZGV2aWNlX2lkKHNwaSktPmRyaXZlcl9kYXRhOwogCQlwZGF0YSA9IGRldl9nZXRfcGxhdGRhdGEoJnNwaS0+ZGV2KTsKLQkJaWYgKCFwZGF0YSB8fCAhZ3Bpb19pc192YWxpZChwZGF0YS0+YmFzZSkpIHsKLQkJCWRldl9kYmcoJnNwaS0+ZGV2LAotCQkJCQkiaW52YWxpZCBvciBtaXNzaW5nIHBsYXRmb3JtIGRhdGFcbiIpOwotCQkJcmV0dXJuIC1FSU5WQUw7CisJCWlmICghcGRhdGEpIHsKKwkJCXBkYXRhID0gZGV2bV9remFsbG9jKCZzcGktPmRldiwKKwkJCQkJc2l6ZW9mKHN0cnVjdCBtY3AyM3MwOF9wbGF0Zm9ybV9kYXRhKSwKKwkJCQkJR0ZQX0tFUk5FTCk7CisJCQlwZGF0YS0+YmFzZSA9IC0xOwogCQl9CiAKIAkJZm9yIChhZGRyID0gMDsgYWRkciA8IEFSUkFZX1NJWkUocGRhdGEtPmNoaXApOyBhZGRyKyspIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3Bpby9ncGlvLW9tYXAuYyBiL2RyaXZlcnMvZ3Bpby9ncGlvLW9tYXAuYwppbmRleCAzMDY0NmNmLi5mNDc2YWUyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwaW8vZ3Bpby1vbWFwLmMKKysrIGIvZHJpdmVycy9ncGlvL2dwaW8tb21hcC5jCkBAIC04OCw2ICs4OCw4IEBACiAjZGVmaW5lIEJBTktfVVNFRChiYW5rKSAoYmFuay0+bW9kX3VzYWdlIHx8IGJhbmstPmlycV91c2FnZSkKICNkZWZpbmUgTElORV9VU0VEKGxpbmUsIG9mZnNldCkgKGxpbmUgJiAoQklUKG9mZnNldCkpKQogCitzdGF0aWMgdm9pZCBvbWFwX2dwaW9fdW5tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpOworCiBzdGF0aWMgaW50IG9tYXBfaXJxX3RvX2dwaW8oc3RydWN0IGdwaW9fYmFuayAqYmFuaywgdW5zaWduZWQgaW50IGdwaW9faXJxKQogewogCXJldHVybiBiYW5rLT5jaGlwLmJhc2UgKyBncGlvX2lycTsKQEAgLTQ3Nyw2ICs0NzksMTYgQEAKIAlyZXR1cm4gcmVhZGxfcmVsYXhlZChyZWcpICYgbWFzazsKIH0KIAorc3RhdGljIHZvaWQgb21hcF9ncGlvX2luaXRfaXJxKHN0cnVjdCBncGlvX2JhbmsgKmJhbmssIHVuc2lnbmVkIGdwaW8sCisJCQkgICAgICAgdW5zaWduZWQgb2Zmc2V0KQoreworCWlmICghTElORV9VU0VEKGJhbmstPm1vZF91c2FnZSwgb2Zmc2V0KSkgeworCQlvbWFwX2VuYWJsZV9ncGlvX21vZHVsZShiYW5rLCBvZmZzZXQpOworCQlvbWFwX3NldF9ncGlvX2RpcmVjdGlvbihiYW5rLCBvZmZzZXQsIDEpOworCX0KKwliYW5rLT5pcnFfdXNhZ2UgfD0gQklUKEdQSU9fSU5ERVgoYmFuaywgZ3BpbykpOworfQorCiBzdGF0aWMgaW50IG9tYXBfZ3Bpb19pcnFfdHlwZShzdHJ1Y3QgaXJxX2RhdGEgKmQsIHVuc2lnbmVkIHR5cGUpCiB7CiAJc3RydWN0IGdwaW9fYmFuayAqYmFuayA9IG9tYXBfaXJxX2RhdGFfZ2V0X2JhbmsoZCk7CkBAIC01MDYsMTUgKzUxOCwxMSBAQAogCXNwaW5fbG9ja19pcnFzYXZlKCZiYW5rLT5sb2NrLCBmbGFncyk7CiAJb2Zmc2V0ID0gR1BJT19JTkRFWChiYW5rLCBncGlvKTsKIAlyZXR2YWwgPSBvbWFwX3NldF9ncGlvX3RyaWdnZXJpbmcoYmFuaywgb2Zmc2V0LCB0eXBlKTsKLQlpZiAoIUxJTkVfVVNFRChiYW5rLT5tb2RfdXNhZ2UsIG9mZnNldCkpIHsKLQkJb21hcF9lbmFibGVfZ3Bpb19tb2R1bGUoYmFuaywgb2Zmc2V0KTsKLQkJb21hcF9zZXRfZ3Bpb19kaXJlY3Rpb24oYmFuaywgb2Zmc2V0LCAxKTsKLQl9IGVsc2UgaWYgKCFvbWFwX2dwaW9faXNfaW5wdXQoYmFuaywgQklUKG9mZnNldCkpKSB7CisJb21hcF9ncGlvX2luaXRfaXJxKGJhbmssIGdwaW8sIG9mZnNldCk7CisJaWYgKCFvbWFwX2dwaW9faXNfaW5wdXQoYmFuaywgQklUKG9mZnNldCkpKSB7CiAJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmJhbmstPmxvY2ssIGZsYWdzKTsKIAkJcmV0dXJuIC1FSU5WQUw7CiAJfQotCi0JYmFuay0+aXJxX3VzYWdlIHw9IEJJVChHUElPX0lOREVYKGJhbmssIGdwaW8pKTsKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZiYW5rLT5sb2NrLCBmbGFncyk7CiAKIAlpZiAodHlwZSAmIChJUlFfVFlQRV9MRVZFTF9MT1cgfCBJUlFfVFlQRV9MRVZFTF9ISUdIKSkKQEAgLTc5Miw2ICs4MDAsMjQgQEAKIAlwbV9ydW50aW1lX3B1dChiYW5rLT5kZXYpOwogfQogCitzdGF0aWMgdW5zaWduZWQgaW50IG9tYXBfZ3Bpb19pcnFfc3RhcnR1cChzdHJ1Y3QgaXJxX2RhdGEgKmQpCit7CisJc3RydWN0IGdwaW9fYmFuayAqYmFuayA9IG9tYXBfaXJxX2RhdGFfZ2V0X2JhbmsoZCk7CisJdW5zaWduZWQgaW50IGdwaW8gPSBvbWFwX2lycV90b19ncGlvKGJhbmssIGQtPmh3aXJxKTsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCXVuc2lnbmVkIG9mZnNldCA9IEdQSU9fSU5ERVgoYmFuaywgZ3Bpbyk7CisKKwlpZiAoIUJBTktfVVNFRChiYW5rKSkKKwkJcG1fcnVudGltZV9nZXRfc3luYyhiYW5rLT5kZXYpOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJmJhbmstPmxvY2ssIGZsYWdzKTsKKwlvbWFwX2dwaW9faW5pdF9pcnEoYmFuaywgZ3Bpbywgb2Zmc2V0KTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZiYW5rLT5sb2NrLCBmbGFncyk7CisJb21hcF9ncGlvX3VubWFza19pcnEoZCk7CisKKwlyZXR1cm4gMDsKK30KKwogc3RhdGljIHZvaWQgb21hcF9ncGlvX2lycV9zaHV0ZG93bihzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7CiAJc3RydWN0IGdwaW9fYmFuayAqYmFuayA9IG9tYXBfaXJxX2RhdGFfZ2V0X2JhbmsoZCk7CkBAIC0xMTgxLDYgKzEyMDcsNyBAQAogCWlmICghaXJxYykKIAkJcmV0dXJuIC1FTk9NRU07CiAKKwlpcnFjLT5pcnFfc3RhcnR1cCA9IG9tYXBfZ3Bpb19pcnFfc3RhcnR1cCwKIAlpcnFjLT5pcnFfc2h1dGRvd24gPSBvbWFwX2dwaW9faXJxX3NodXRkb3duLAogCWlycWMtPmlycV9hY2sgPSBvbWFwX2dwaW9fYWNrX2lycSwKIAlpcnFjLT5pcnFfbWFzayA9IG9tYXBfZ3Bpb19tYXNrX2lycSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3Bpby9ncGlvbGliLW9mLmMgYi9kcml2ZXJzL2dwaW8vZ3Bpb2xpYi1vZi5jCmluZGV4IDYwNGRiZTYuLjA4MjYxZjIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3Bpby9ncGlvbGliLW9mLmMKKysrIGIvZHJpdmVycy9ncGlvL2dwaW9saWItb2YuYwpAQCAtNDUsOCArNDUsMTQgQEAKIAkJcmV0dXJuIGZhbHNlOwogCiAJcmV0ID0gZ2MtPm9mX3hsYXRlKGdjLCAmZ2dfZGF0YS0+Z3Bpb3NwZWMsIGdnX2RhdGEtPmZsYWdzKTsKLQlpZiAocmV0IDwgMCkKLQkJcmV0dXJuIGZhbHNlOworCWlmIChyZXQgPCAwKSB7CisJCS8qIFdlJ3ZlIGZvdW5kIHRoZSBncGlvIGNoaXAsIGJ1dCB0aGUgdHJhbnNsYXRpb24gZmFpbGVkLgorCQkgKiBSZXR1cm4gdHJ1ZSB0byBzdG9wIGxvb2tpbmcgYW5kIHJldHVybiB0aGUgdHJhbnNsYXRpb24KKwkJICogZXJyb3IgdmlhIG91dF9ncGlvCisJCSAqLworCQlnZ19kYXRhLT5vdXRfZ3BpbyA9IEVSUl9QVFIocmV0KTsKKwkJcmV0dXJuIHRydWU7CisJIH0KIAogCWdnX2RhdGEtPm91dF9ncGlvID0gZ3Bpb2NoaXBfZ2V0X2Rlc2MoZ2MsIHJldCk7CiAJcmV0dXJuIHRydWU7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwaW8vZ3Bpb2xpYi1zeXNmcy5jIGIvZHJpdmVycy9ncGlvL2dwaW9saWItc3lzZnMuYwppbmRleCAyYWMxODAwLi43NzIyZWQ1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwaW8vZ3Bpb2xpYi1zeXNmcy5jCisrKyBiL2RyaXZlcnMvZ3Bpby9ncGlvbGliLXN5c2ZzLmMKQEAgLTEyOCw3ICsxMjgsNyBAQAogCXJldHVybiBzdGF0dXM7CiB9CiAKLXN0YXRpYyBjb25zdCBERVZJQ0VfQVRUUih2YWx1ZSwgMDY0NCwKK3N0YXRpYyBERVZJQ0VfQVRUUih2YWx1ZSwgMDY0NCwKIAkJZ3Bpb192YWx1ZV9zaG93LCBncGlvX3ZhbHVlX3N0b3JlKTsKIAogc3RhdGljIGlycXJldHVybl90IGdwaW9fc3lzZnNfaXJxKGludCBpcnEsIHZvaWQgKnByaXYpCkBAIC0zNTMsMTcgKzM1Myw0NiBAQAogCXJldHVybiBzdGF0dXMgPyA6IHNpemU7CiB9CiAKLXN0YXRpYyBjb25zdCBERVZJQ0VfQVRUUihhY3RpdmVfbG93LCAwNjQ0LAorc3RhdGljIERFVklDRV9BVFRSKGFjdGl2ZV9sb3csIDA2NDQsCiAJCWdwaW9fYWN0aXZlX2xvd19zaG93LCBncGlvX2FjdGl2ZV9sb3dfc3RvcmUpOwogCi1zdGF0aWMgY29uc3Qgc3RydWN0IGF0dHJpYnV0ZSAqZ3Bpb19hdHRyc1tdID0geworc3RhdGljIHVtb2RlX3QgZ3Bpb19pc192aXNpYmxlKHN0cnVjdCBrb2JqZWN0ICprb2JqLCBzdHJ1Y3QgYXR0cmlidXRlICphdHRyLAorCQkJICAgICAgIGludCBuKQoreworCXN0cnVjdCBkZXZpY2UgKmRldiA9IGNvbnRhaW5lcl9vZihrb2JqLCBzdHJ1Y3QgZGV2aWNlLCBrb2JqKTsKKwlzdHJ1Y3QgZ3Bpb19kZXNjICpkZXNjID0gZGV2X2dldF9kcnZkYXRhKGRldik7CisJdW1vZGVfdCBtb2RlID0gYXR0ci0+bW9kZTsKKwlib29sIHNob3dfZGlyZWN0aW9uID0gdGVzdF9iaXQoRkxBR19TWVNGU19ESVIsICZkZXNjLT5mbGFncyk7CisKKwlpZiAoYXR0ciA9PSAmZGV2X2F0dHJfZGlyZWN0aW9uLmF0dHIpIHsKKwkJaWYgKCFzaG93X2RpcmVjdGlvbikKKwkJCW1vZGUgPSAwOworCX0gZWxzZSBpZiAoYXR0ciA9PSAmZGV2X2F0dHJfZWRnZS5hdHRyKSB7CisJCWlmIChncGlvZF90b19pcnEoZGVzYykgPCAwKQorCQkJbW9kZSA9IDA7CisJCWlmICghc2hvd19kaXJlY3Rpb24gJiYgdGVzdF9iaXQoRkxBR19JU19PVVQsICZkZXNjLT5mbGFncykpCisJCQltb2RlID0gMDsKKwl9CisKKwlyZXR1cm4gbW9kZTsKK30KKworc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGUgKmdwaW9fYXR0cnNbXSA9IHsKKwkmZGV2X2F0dHJfZGlyZWN0aW9uLmF0dHIsCisJJmRldl9hdHRyX2VkZ2UuYXR0ciwKIAkmZGV2X2F0dHJfdmFsdWUuYXR0ciwKIAkmZGV2X2F0dHJfYWN0aXZlX2xvdy5hdHRyLAogCU5VTEwsCiB9OwogCi1zdGF0aWMgY29uc3Qgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCBncGlvX2F0dHJfZ3JvdXAgPSB7Ci0JLmF0dHJzID0gKHN0cnVjdCBhdHRyaWJ1dGUgKiopIGdwaW9fYXR0cnMsCitzdGF0aWMgY29uc3Qgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCBncGlvX2dyb3VwID0geworCS5hdHRycyA9IGdwaW9fYXR0cnMsCisJLmlzX3Zpc2libGUgPSBncGlvX2lzX3Zpc2libGUsCit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCAqZ3Bpb19ncm91cHNbXSA9IHsKKwkmZ3Bpb19ncm91cCwKKwlOVUxMCiB9OwogCiAvKgpAQCAtNDAwLDE2ICs0MjksMTMgQEAKIH0KIHN0YXRpYyBERVZJQ0VfQVRUUihuZ3BpbywgMDQ0NCwgY2hpcF9uZ3Bpb19zaG93LCBOVUxMKTsKIAotc3RhdGljIGNvbnN0IHN0cnVjdCBhdHRyaWJ1dGUgKmdwaW9jaGlwX2F0dHJzW10gPSB7CitzdGF0aWMgc3RydWN0IGF0dHJpYnV0ZSAqZ3Bpb2NoaXBfYXR0cnNbXSA9IHsKIAkmZGV2X2F0dHJfYmFzZS5hdHRyLAogCSZkZXZfYXR0cl9sYWJlbC5hdHRyLAogCSZkZXZfYXR0cl9uZ3Bpby5hdHRyLAogCU5VTEwsCiB9OwotCi1zdGF0aWMgY29uc3Qgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCBncGlvY2hpcF9hdHRyX2dyb3VwID0gewotCS5hdHRycyA9IChzdHJ1Y3QgYXR0cmlidXRlICoqKSBncGlvY2hpcF9hdHRycywKLX07CitBVFRSSUJVVEVfR1JPVVBTKGdwaW9jaGlwKTsKIAogLyoKICAqIC9zeXMvY2xhc3MvZ3Bpby9leHBvcnQgLi4uIHdyaXRlLW9ubHkKQEAgLTU1Niw0NSArNTgyLDMwIEBACiAJCWdvdG8gZmFpbF91bmxvY2s7CiAJfQogCi0JaWYgKCFkZXNjLT5jaGlwLT5kaXJlY3Rpb25faW5wdXQgfHwgIWRlc2MtPmNoaXAtPmRpcmVjdGlvbl9vdXRwdXQpCi0JCWRpcmVjdGlvbl9tYXlfY2hhbmdlID0gZmFsc2U7CisJaWYgKGRlc2MtPmNoaXAtPmRpcmVjdGlvbl9pbnB1dCAmJiBkZXNjLT5jaGlwLT5kaXJlY3Rpb25fb3V0cHV0ICYmCisJCQlkaXJlY3Rpb25fbWF5X2NoYW5nZSkgeworCQlzZXRfYml0KEZMQUdfU1lTRlNfRElSLCAmZGVzYy0+ZmxhZ3MpOworCX0KKwogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmdwaW9fbG9jaywgZmxhZ3MpOwogCiAJb2Zmc2V0ID0gZ3Bpb19jaGlwX2h3Z3BpbyhkZXNjKTsKIAlpZiAoZGVzYy0+Y2hpcC0+bmFtZXMgJiYgZGVzYy0+Y2hpcC0+bmFtZXNbb2Zmc2V0XSkKIAkJaW9uYW1lID0gZGVzYy0+Y2hpcC0+bmFtZXNbb2Zmc2V0XTsKIAotCWRldiA9IGRldmljZV9jcmVhdGUoJmdwaW9fY2xhc3MsIGRlc2MtPmNoaXAtPmRldiwgTUtERVYoMCwgMCksCi0JCQkgICAgZGVzYywgaW9uYW1lID8gaW9uYW1lIDogImdwaW8ldSIsCi0JCQkgICAgZGVzY190b19ncGlvKGRlc2MpKTsKKwlkZXYgPSBkZXZpY2VfY3JlYXRlX3dpdGhfZ3JvdXBzKCZncGlvX2NsYXNzLCBkZXNjLT5jaGlwLT5kZXYsCisJCQkJCU1LREVWKDAsIDApLCBkZXNjLCBncGlvX2dyb3VwcywKKwkJCQkJaW9uYW1lID8gaW9uYW1lIDogImdwaW8ldSIsCisJCQkJCWRlc2NfdG9fZ3BpbyhkZXNjKSk7CiAJaWYgKElTX0VSUihkZXYpKSB7CiAJCXN0YXR1cyA9IFBUUl9FUlIoZGV2KTsKIAkJZ290byBmYWlsX3VubG9jazsKIAl9CiAKLQlzdGF0dXMgPSBzeXNmc19jcmVhdGVfZ3JvdXAoJmRldi0+a29iaiwgJmdwaW9fYXR0cl9ncm91cCk7Ci0JaWYgKHN0YXR1cykKLQkJZ290byBmYWlsX3VucmVnaXN0ZXJfZGV2aWNlOwotCi0JaWYgKGRpcmVjdGlvbl9tYXlfY2hhbmdlKSB7Ci0JCXN0YXR1cyA9IGRldmljZV9jcmVhdGVfZmlsZShkZXYsICZkZXZfYXR0cl9kaXJlY3Rpb24pOwotCQlpZiAoc3RhdHVzKQotCQkJZ290byBmYWlsX3VucmVnaXN0ZXJfZGV2aWNlOwotCX0KLQotCWlmIChncGlvZF90b19pcnEoZGVzYykgPj0gMCAmJiAoZGlyZWN0aW9uX21heV9jaGFuZ2UgfHwKLQkJCQkgICAgICAgIXRlc3RfYml0KEZMQUdfSVNfT1VULCAmZGVzYy0+ZmxhZ3MpKSkgewotCQlzdGF0dXMgPSBkZXZpY2VfY3JlYXRlX2ZpbGUoZGV2LCAmZGV2X2F0dHJfZWRnZSk7Ci0JCWlmIChzdGF0dXMpCi0JCQlnb3RvIGZhaWxfdW5yZWdpc3Rlcl9kZXZpY2U7Ci0JfQotCiAJc2V0X2JpdChGTEFHX0VYUE9SVCwgJmRlc2MtPmZsYWdzKTsKIAltdXRleF91bmxvY2soJnN5c2ZzX2xvY2spOwogCXJldHVybiAwOwogCi1mYWlsX3VucmVnaXN0ZXJfZGV2aWNlOgotCWRldmljZV91bnJlZ2lzdGVyKGRldik7CiBmYWlsX3VubG9jazoKIAltdXRleF91bmxvY2soJnN5c2ZzX2xvY2spOwogCWdwaW9kX2RiZyhkZXNjLCAiJXM6IHN0YXR1cyAlZFxuIiwgX19mdW5jX18sIHN0YXR1cyk7CkBAIC02MzcsNiArNjQ4LDcgQEAKIAkJaWYgKHRkZXYgIT0gTlVMTCkgewogCQkJc3RhdHVzID0gc3lzZnNfY3JlYXRlX2xpbmsoJmRldi0+a29iaiwgJnRkZXYtPmtvYmosCiAJCQkJCQluYW1lKTsKKwkJCXB1dF9kZXZpY2UodGRldik7CiAJCX0gZWxzZSB7CiAJCQlzdGF0dXMgPSAtRU5PREVWOwogCQl9CkBAIC02ODQsNyArNjk2LDcgQEAKIAl9CiAKIAlzdGF0dXMgPSBzeXNmc19zZXRfYWN0aXZlX2xvdyhkZXNjLCBkZXYsIHZhbHVlKTsKLQorCXB1dF9kZXZpY2UoZGV2KTsKIHVubG9jazoKIAltdXRleF91bmxvY2soJnN5c2ZzX2xvY2spOwogCkBAIC03MTgsNiArNzMwLDcgQEAKIAkJZGV2ID0gY2xhc3NfZmluZF9kZXZpY2UoJmdwaW9fY2xhc3MsIE5VTEwsIGRlc2MsIG1hdGNoX2V4cG9ydCk7CiAJCWlmIChkZXYpIHsKIAkJCWdwaW9fc2V0dXBfaXJxKGRlc2MsIGRldiwgMCk7CisJCQljbGVhcl9iaXQoRkxBR19TWVNGU19ESVIsICZkZXNjLT5mbGFncyk7CiAJCQljbGVhcl9iaXQoRkxBR19FWFBPUlQsICZkZXNjLT5mbGFncyk7CiAJCX0gZWxzZQogCQkJc3RhdHVzID0gLUVOT0RFVjsKQEAgLTc1MCwxMyArNzYzLDEzIEBACiAKIAkvKiB1c2UgY2hpcC0+YmFzZSBmb3IgdGhlIElEOyBpdCdzIGFscmVhZHkga25vd24gdG8gYmUgdW5pcXVlICovCiAJbXV0ZXhfbG9jaygmc3lzZnNfbG9jayk7Ci0JZGV2ID0gZGV2aWNlX2NyZWF0ZSgmZ3Bpb19jbGFzcywgY2hpcC0+ZGV2LCBNS0RFVigwLCAwKSwgY2hpcCwKLQkJCQkiZ3Bpb2NoaXAlZCIsIGNoaXAtPmJhc2UpOwotCWlmICghSVNfRVJSKGRldikpIHsKLQkJc3RhdHVzID0gc3lzZnNfY3JlYXRlX2dyb3VwKCZkZXYtPmtvYmosCi0JCQkJJmdwaW9jaGlwX2F0dHJfZ3JvdXApOwotCX0gZWxzZQorCWRldiA9IGRldmljZV9jcmVhdGVfd2l0aF9ncm91cHMoJmdwaW9fY2xhc3MsIGNoaXAtPmRldiwgTUtERVYoMCwgMCksCisJCQkJCWNoaXAsIGdwaW9jaGlwX2dyb3VwcywKKwkJCQkJImdwaW9jaGlwJWQiLCBjaGlwLT5iYXNlKTsKKwlpZiAoSVNfRVJSKGRldikpCiAJCXN0YXR1cyA9IFBUUl9FUlIoZGV2KTsKKwllbHNlCisJCXN0YXR1cyA9IDA7CiAJY2hpcC0+ZXhwb3J0ZWQgPSAoc3RhdHVzID09IDApOwogCW11dGV4X3VubG9jaygmc3lzZnNfbG9jayk7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3Bpby9ncGlvbGliLmMgYi9kcml2ZXJzL2dwaW8vZ3Bpb2xpYi5jCmluZGV4IDQ4N2FmZTYuLjU2OGFhMmIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3Bpby9ncGlvbGliLmMKKysrIGIvZHJpdmVycy9ncGlvL2dwaW9saWIuYwpAQCAtMjQ4LDI5ICsyNDgsMzAgQEAKIAkJYmFzZSA9IGdwaW9jaGlwX2ZpbmRfYmFzZShjaGlwLT5uZ3Bpbyk7CiAJCWlmIChiYXNlIDwgMCkgewogCQkJc3RhdHVzID0gYmFzZTsKLQkJCWdvdG8gdW5sb2NrOworCQkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZ3Bpb19sb2NrLCBmbGFncyk7CisJCQlnb3RvIGVycl9mcmVlX2Rlc2NzOwogCQl9CiAJCWNoaXAtPmJhc2UgPSBiYXNlOwogCX0KIAogCXN0YXR1cyA9IGdwaW9jaGlwX2FkZF90b19saXN0KGNoaXApOworCWlmIChzdGF0dXMpIHsKKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZ3Bpb19sb2NrLCBmbGFncyk7CisJCWdvdG8gZXJyX2ZyZWVfZGVzY3M7CisJfQogCi0JaWYgKHN0YXR1cyA9PSAwKSB7Ci0JCWZvciAoaWQgPSAwOyBpZCA8IGNoaXAtPm5ncGlvOyBpZCsrKSB7Ci0JCQlzdHJ1Y3QgZ3Bpb19kZXNjICpkZXNjID0gJmRlc2NzW2lkXTsKLQkJCWRlc2MtPmNoaXAgPSBjaGlwOworCWZvciAoaWQgPSAwOyBpZCA8IGNoaXAtPm5ncGlvOyBpZCsrKSB7CisJCXN0cnVjdCBncGlvX2Rlc2MgKmRlc2MgPSAmZGVzY3NbaWRdOwogCi0JCQkvKiBSRVZJU0lUOiAgbW9zdCBoYXJkd2FyZSBpbml0aWFsaXplcyBHUElPcyBhcwotCQkJICogaW5wdXRzIChvZnRlbiB3aXRoIHB1bGx1cHMgZW5hYmxlZCkgc28gcG93ZXIKLQkJCSAqIHVzYWdlIGlzIG1pbmltaXplZC4gIExpbnV4IGNvZGUgc2hvdWxkIHNldCB0aGUKLQkJCSAqIGdwaW8gZGlyZWN0aW9uIGZpcnN0IHRoaW5nOyBidXQgdW50aWwgaXQgZG9lcywKLQkJCSAqIGFuZCBpbiBjYXNlIGNoaXAtPmdldF9kaXJlY3Rpb24gaXMgbm90IHNldCwKLQkJCSAqIHdlIG1heSBleHBvc2UgdGhlIHdyb25nIGRpcmVjdGlvbiBpbiBzeXNmcy4KLQkJCSAqLwotCQkJZGVzYy0+ZmxhZ3MgPSAhY2hpcC0+ZGlyZWN0aW9uX2lucHV0Ci0JCQkJPyAoMSA8PCBGTEFHX0lTX09VVCkKLQkJCQk6IDA7Ci0JCX0KKwkJZGVzYy0+Y2hpcCA9IGNoaXA7CisKKwkJLyogUkVWSVNJVDogbW9zdCBoYXJkd2FyZSBpbml0aWFsaXplcyBHUElPcyBhcyBpbnB1dHMgKG9mdGVuCisJCSAqIHdpdGggcHVsbHVwcyBlbmFibGVkKSBzbyBwb3dlciB1c2FnZSBpcyBtaW5pbWl6ZWQuIExpbnV4CisJCSAqIGNvZGUgc2hvdWxkIHNldCB0aGUgZ3BpbyBkaXJlY3Rpb24gZmlyc3QgdGhpbmc7IGJ1dCB1bnRpbAorCQkgKiBpdCBkb2VzLCBhbmQgaW4gY2FzZSBjaGlwLT5nZXRfZGlyZWN0aW9uIGlzIG5vdCBzZXQsIHdlIG1heQorCQkgKiBleHBvc2UgdGhlIHdyb25nIGRpcmVjdGlvbiBpbiBzeXNmcy4KKwkJICovCisJCWRlc2MtPmZsYWdzID0gIWNoaXAtPmRpcmVjdGlvbl9pbnB1dCA/ICgxIDw8IEZMQUdfSVNfT1VUKSA6IDA7CiAJfQogCiAJY2hpcC0+ZGVzYyA9IGRlc2NzOwpAQCAtMjg0LDEyICsyODUsOSBAQAogCW9mX2dwaW9jaGlwX2FkZChjaGlwKTsKIAlhY3BpX2dwaW9jaGlwX2FkZChjaGlwKTsKIAotCWlmIChzdGF0dXMpCi0JCWdvdG8gZmFpbDsKLQogCXN0YXR1cyA9IGdwaW9jaGlwX2V4cG9ydChjaGlwKTsKIAlpZiAoc3RhdHVzKQotCQlnb3RvIGZhaWw7CisJCWdvdG8gZXJyX3JlbW92ZV9jaGlwOwogCiAJcHJfZGVidWcoIiVzOiByZWdpc3RlcmVkIEdQSU9zICVkIHRvICVkIG9uIGRldmljZTogJXNcbiIsIF9fZnVuY19fLAogCQljaGlwLT5iYXNlLCBjaGlwLT5iYXNlICsgY2hpcC0+bmdwaW8gLSAxLApAQCAtMjk3LDExICsyOTUsMTUgQEAKIAogCXJldHVybiAwOwogCi11bmxvY2s6CitlcnJfcmVtb3ZlX2NoaXA6CisJYWNwaV9ncGlvY2hpcF9yZW1vdmUoY2hpcCk7CisJb2ZfZ3Bpb2NoaXBfcmVtb3ZlKGNoaXApOworCXNwaW5fbG9ja19pcnFzYXZlKCZncGlvX2xvY2ssIGZsYWdzKTsKKwlsaXN0X2RlbCgmY2hpcC0+bGlzdCk7CiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZ3Bpb19sb2NrLCBmbGFncyk7Ci1mYWlsOgotCWtmcmVlKGRlc2NzKTsKIAljaGlwLT5kZXNjID0gTlVMTDsKK2Vycl9mcmVlX2Rlc2NzOgorCWtmcmVlKGRlc2NzKTsKIAogCS8qIGZhaWx1cmVzIGhlcmUgY2FuIG1lYW4gc3lzdGVtcyB3b24ndCBib290Li4uICovCiAJcHJfZXJyKCIlczogR1BJT3MgJWQuLiVkICglcykgZmFpbGVkIHRvIHJlZ2lzdGVyXG4iLCBfX2Z1bmNfXywKQEAgLTMyNSwxNCArMzI3LDE1IEBACiAJdW5zaWduZWQgbG9uZwlmbGFnczsKIAl1bnNpZ25lZAlpZDsKIAotCWFjcGlfZ3Bpb2NoaXBfcmVtb3ZlKGNoaXApOwotCi0Jc3Bpbl9sb2NrX2lycXNhdmUoJmdwaW9fbG9jaywgZmxhZ3MpOworCWdwaW9jaGlwX3VuZXhwb3J0KGNoaXApOwogCiAJZ3Bpb2NoaXBfaXJxY2hpcF9yZW1vdmUoY2hpcCk7CisKKwlhY3BpX2dwaW9jaGlwX3JlbW92ZShjaGlwKTsKIAlncGlvY2hpcF9yZW1vdmVfcGluX3JhbmdlcyhjaGlwKTsKIAlvZl9ncGlvY2hpcF9yZW1vdmUoY2hpcCk7CiAKKwlzcGluX2xvY2tfaXJxc2F2ZSgmZ3Bpb19sb2NrLCBmbGFncyk7CiAJZm9yIChpZCA9IDA7IGlkIDwgY2hpcC0+bmdwaW87IGlkKyspIHsKIAkJaWYgKHRlc3RfYml0KEZMQUdfUkVRVUVTVEVELCAmY2hpcC0+ZGVzY1tpZF0uZmxhZ3MpKQogCQkJZGV2X2NyaXQoY2hpcC0+ZGV2LCAiUkVNT1ZJTkcgR1BJT0NISVAgV0lUSCBHUElPUyBTVElMTCBSRVFVRVNURURcbiIpOwpAQCAtMzQyLDcgKzM0NSw2IEBACiAKIAlsaXN0X2RlbCgmY2hpcC0+bGlzdCk7CiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZ3Bpb19sb2NrLCBmbGFncyk7Ci0JZ3Bpb2NoaXBfdW5leHBvcnQoY2hpcCk7CiAKIAlrZnJlZShjaGlwLT5kZXNjKTsKIAljaGlwLT5kZXNjID0gTlVMTDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3Bpby9ncGlvbGliLmggYi9kcml2ZXJzL2dwaW8vZ3Bpb2xpYi5oCmluZGV4IGUzYTUyMTEuLjU1MGE1ZWEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3Bpby9ncGlvbGliLmgKKysrIGIvZHJpdmVycy9ncGlvL2dwaW9saWIuaApAQCAtNzcsNiArNzcsNyBAQAogI2RlZmluZSBGTEFHX09QRU5fRFJBSU4JNwkvKiBHcGlvIGlzIG9wZW4gZHJhaW4gdHlwZSAqLwogI2RlZmluZSBGTEFHX09QRU5fU09VUkNFIDgJLyogR3BpbyBpcyBvcGVuIHNvdXJjZSB0eXBlICovCiAjZGVmaW5lIEZMQUdfVVNFRF9BU19JUlEgOQkvKiBHUElPIGlzIGNvbm5lY3RlZCB0byBhbiBJUlEgKi8KKyNkZWZpbmUgRkxBR19TWVNGU19ESVIJMTAJLyogc2hvdyBzeXNmcyBkaXJlY3Rpb24gYXR0cmlidXRlICovCiAKICNkZWZpbmUgSURfU0hJRlQJMTYJLyogYWRkIG5ldyBmbGFncyBiZWZvcmUgdGhpcyBvbmUgKi8KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRrZmQvTWFrZWZpbGUgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGtmZC9NYWtlZmlsZQppbmRleCBiZTYyNDZkLi4zMDdhMzA5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGtmZC9NYWtlZmlsZQorKysgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGtmZC9NYWtlZmlsZQpAQCAtOCw3ICs4LDYgQEAKIAkJa2ZkX3Bhc2lkLm8ga2ZkX2Rvb3JiZWxsLm8ga2ZkX2ZsYXRfbWVtb3J5Lm8gXAogCQlrZmRfcHJvY2Vzcy5vIGtmZF9xdWV1ZS5vIGtmZF9tcWRfbWFuYWdlci5vIFwKIAkJa2ZkX2tlcm5lbF9xdWV1ZS5vIGtmZF9wYWNrZXRfbWFuYWdlci5vIFwKLQkJa2ZkX3Byb2Nlc3NfcXVldWVfbWFuYWdlci5vIGtmZF9kZXZpY2VfcXVldWVfbWFuYWdlci5vIFwKLQkJa2ZkX2ludGVycnVwdC5vCisJCWtmZF9wcm9jZXNzX3F1ZXVlX21hbmFnZXIubyBrZmRfZGV2aWNlX3F1ZXVlX21hbmFnZXIubwogCiBvYmotJChDT05GSUdfSFNBX0FNRCkJKz0gYW1ka2ZkLm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1ka2ZkL2tmZF9kZXZpY2UuYyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1ka2ZkL2tmZF9kZXZpY2UuYwppbmRleCA0Mzg4NGViLi4yNWJjNDdmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGtmZC9rZmRfZGV2aWNlLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRrZmQva2ZkX2RldmljZS5jCkBAIC0yNiw2ICsyNiw3IEBACiAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgogI2luY2x1ZGUgImtmZF9wcml2LmgiCiAjaW5jbHVkZSAia2ZkX2RldmljZV9xdWV1ZV9tYW5hZ2VyLmgiCisjaW5jbHVkZSAia2ZkX3BtNF9oZWFkZXJzLmgiCiAKICNkZWZpbmUgTVFEX1NJWkVfQUxJR05FRCA3NjgKIApAQCAtMTY5LDkgKzE3MCw4IEBACiAJa2ZkLT5zaGFyZWRfcmVzb3VyY2VzID0gKmdwdV9yZXNvdXJjZXM7CiAKIAkvKiBjYWxjdWxhdGUgbWF4IHNpemUgb2YgbXFkcyBuZWVkZWQgZm9yIHF1ZXVlcyAqLwotCXNpemUgPSBtYXhfbnVtX29mX3Byb2Nlc3NlcyAqCi0JCW1heF9udW1fb2ZfcXVldWVzX3Blcl9wcm9jZXNzICoKLQkJa2ZkLT5kZXZpY2VfaW5mby0+bXFkX3NpemVfYWxpZ25lZDsKKwlzaXplID0gbWF4X251bV9vZl9xdWV1ZXNfcGVyX2RldmljZSAqCisJCQlrZmQtPmRldmljZV9pbmZvLT5tcWRfc2l6ZV9hbGlnbmVkOwogCiAJLyogYWRkIGFub3RoZXIgNTEyS0IgZm9yIGFsbCBvdGhlciBhbGxvY2F0aW9ucyBvbiBnYXJ0ICovCiAJc2l6ZSArPSA1MTIgKiAxMDI0OwpAQCAtMTkyLDEzICsxOTIsNiBAQAogCQlnb3RvIGtmZF90b3BvbG9neV9hZGRfZGV2aWNlX2Vycm9yOwogCX0KIAotCWlmIChrZmRfaW50ZXJydXB0X2luaXQoa2ZkKSkgewotCQlkZXZfZXJyKGtmZF9kZXZpY2UsCi0JCQkiRXJyb3IgaW5pdGlhbGl6aW5nIGludGVycnVwdHMgZm9yIGRldmljZSAoJXg6JXgpXG4iLAotCQkJa2ZkLT5wZGV2LT52ZW5kb3IsIGtmZC0+cGRldi0+ZGV2aWNlKTsKLQkJZ290byBrZmRfaW50ZXJydXB0X2Vycm9yOwotCX0KLQogCWlmICghZGV2aWNlX2lvbW11X3Bhc2lkX2luaXQoa2ZkKSkgewogCQlkZXZfZXJyKGtmZF9kZXZpY2UsCiAJCQkiRXJyb3IgaW5pdGlhbGl6aW5nIGlvbW11djIgZm9yIGRldmljZSAoJXg6JXgpXG4iLApAQCAtMjM3LDggKzIzMCw2IEBACiBkZXZpY2VfcXVldWVfbWFuYWdlcl9lcnJvcjoKIAlhbWRfaW9tbXVfZnJlZV9kZXZpY2Uoa2ZkLT5wZGV2KTsKIGRldmljZV9pb21tdV9wYXNpZF9lcnJvcjoKLQlrZmRfaW50ZXJydXB0X2V4aXQoa2ZkKTsKLWtmZF9pbnRlcnJ1cHRfZXJyb3I6CiAJa2ZkX3RvcG9sb2d5X3JlbW92ZV9kZXZpY2Uoa2ZkKTsKIGtmZF90b3BvbG9neV9hZGRfZGV2aWNlX2Vycm9yOgogCWtmZDJrZ2QtPmZpbmlfc2FfbWFuYWdlcihrZmQtPmtnZCk7CkBAIC0yNTQsNyArMjQ1LDYgQEAKIAlpZiAoa2ZkLT5pbml0X2NvbXBsZXRlKSB7CiAJCWRldmljZV9xdWV1ZV9tYW5hZ2VyX3VuaW5pdChrZmQtPmRxbSk7CiAJCWFtZF9pb21tdV9mcmVlX2RldmljZShrZmQtPnBkZXYpOwotCQlrZmRfaW50ZXJydXB0X2V4aXQoa2ZkKTsKIAkJa2ZkX3RvcG9sb2d5X3JlbW92ZV9kZXZpY2Uoa2ZkKTsKIAl9CiAKQEAgLTI5NiwxMyArMjg2LDUgQEAKIC8qIFRoaXMgaXMgY2FsbGVkIGRpcmVjdGx5IGZyb20gS0dEIGF0IElTUi4gKi8KIHZvaWQga2dkMmtmZF9pbnRlcnJ1cHQoc3RydWN0IGtmZF9kZXYgKmtmZCwgY29uc3Qgdm9pZCAqaWhfcmluZ19lbnRyeSkKIHsKLQlpZiAoa2ZkLT5pbml0X2NvbXBsZXRlKSB7Ci0JCXNwaW5fbG9jaygma2ZkLT5pbnRlcnJ1cHRfbG9jayk7Ci0KLQkJaWYgKGtmZC0+aW50ZXJydXB0c19hY3RpdmUKLQkJICAgICYmIGVucXVldWVfaWhfcmluZ19lbnRyeShrZmQsIGloX3JpbmdfZW50cnkpKQotCQkJc2NoZWR1bGVfd29yaygma2ZkLT5pbnRlcnJ1cHRfd29yayk7Ci0KLQkJc3Bpbl91bmxvY2soJmtmZC0+aW50ZXJydXB0X2xvY2spOwotCX0KKwkvKiBQcm9jZXNzIGludGVycnVwdHMgLyBzY2hlZHVsZSB3b3JrIGFzIG5lY2Vzc2FyeSAqLwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRrZmQva2ZkX2RldmljZV9xdWV1ZV9tYW5hZ2VyLmMgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGtmZC9rZmRfZGV2aWNlX3F1ZXVlX21hbmFnZXIuYwppbmRleCA5Yzg5NjFkLi4wZmQ1OTI3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGtmZC9rZmRfZGV2aWNlX3F1ZXVlX21hbmFnZXIuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGtmZC9rZmRfZGV2aWNlX3F1ZXVlX21hbmFnZXIuYwpAQCAtMTgzLDYgKzE4MywxMyBAQAogCiAJbXV0ZXhfbG9jaygmZHFtLT5sb2NrKTsKIAorCWlmIChkcW0tPnRvdGFsX3F1ZXVlX2NvdW50ID49IG1heF9udW1fb2ZfcXVldWVzX3Blcl9kZXZpY2UpIHsKKwkJcHJfd2FybigiYW1ka2ZkOiBDYW4ndCBjcmVhdGUgbmV3IHVzZXJtb2RlIHF1ZXVlIGJlY2F1c2UgJWQgcXVldWVzIHdlcmUgYWxyZWFkeSBjcmVhdGVkXG4iLAorCQkJCWRxbS0+dG90YWxfcXVldWVfY291bnQpOworCQltdXRleF91bmxvY2soJmRxbS0+bG9jayk7CisJCXJldHVybiAtRVBFUk07CisJfQorCiAJaWYgKGxpc3RfZW1wdHkoJnFwZC0+cXVldWVzX2xpc3QpKSB7CiAJCXJldHZhbCA9IGFsbG9jYXRlX3ZtaWQoZHFtLCBxcGQsIHEpOwogCQlpZiAocmV0dmFsICE9IDApIHsKQEAgLTIwNyw2ICsyMTQsMTQgQEAKIAlsaXN0X2FkZCgmcS0+bGlzdCwgJnFwZC0+cXVldWVzX2xpc3QpOwogCWRxbS0+cXVldWVfY291bnQrKzsKIAorCS8qCisJICogVW5jb25kaXRpb25hbGx5IGluY3JlbWVudCB0aGlzIGNvdW50ZXIsIHJlZ2FyZGxlc3Mgb2YgdGhlIHF1ZXVlJ3MKKwkgKiB0eXBlIG9yIHdoZXRoZXIgdGhlIHF1ZXVlIGlzIGFjdGl2ZS4KKwkgKi8KKwlkcW0tPnRvdGFsX3F1ZXVlX2NvdW50Kys7CisJcHJfZGVidWcoIlRvdGFsIG9mICVkIHF1ZXVlcyBhcmUgYWNjb3VudGFibGUgc28gZmFyXG4iLAorCQkJZHFtLT50b3RhbF9xdWV1ZV9jb3VudCk7CisKIAltdXRleF91bmxvY2soJmRxbS0+bG9jayk7CiAJcmV0dXJuIDA7CiB9CkBAIC0yODAsNyArMjk1LDcgQEAKIAkJCXEtPnF1ZXVlKTsKIAogCXJldHZhbCA9IG1xZC0+bG9hZF9tcWQobXFkLCBxLT5tcWQsIHEtPnBpcGUsCi0JCQlxLT5xdWV1ZSwgcS0+cHJvcGVydGllcy53cml0ZV9wdHIpOworCQkJcS0+cXVldWUsICh1aW50MzJfdCBfX3VzZXIgKikgcS0+cHJvcGVydGllcy53cml0ZV9wdHIpOwogCWlmIChyZXR2YWwgIT0gMCkgewogCQlkZWFsbG9jYXRlX2hxZChkcW0sIHEpOwogCQltcWQtPnVuaW5pdF9tcWQobXFkLCBxLT5tcWQsIHEtPm1xZF9tZW1fb2JqKTsKQEAgLTMyNiw2ICszNDEsMTUgQEAKIAlpZiAobGlzdF9lbXB0eSgmcXBkLT5xdWV1ZXNfbGlzdCkpCiAJCWRlYWxsb2NhdGVfdm1pZChkcW0sIHFwZCwgcSk7CiAJZHFtLT5xdWV1ZV9jb3VudC0tOworCisJLyoKKwkgKiBVbmNvbmRpdGlvbmFsbHkgZGVjcmVtZW50IHRoaXMgY291bnRlciwgcmVnYXJkbGVzcyBvZiB0aGUgcXVldWUncworCSAqIHR5cGUKKwkgKi8KKwlkcW0tPnRvdGFsX3F1ZXVlX2NvdW50LS07CisJcHJfZGVidWcoIlRvdGFsIG9mICVkIHF1ZXVlcyBhcmUgYWNjb3VudGFibGUgc28gZmFyXG4iLAorCQkJZHFtLT50b3RhbF9xdWV1ZV9jb3VudCk7CisKIG91dDoKIAltdXRleF91bmxvY2soJmRxbS0+bG9jayk7CiAJcmV0dXJuIHJldHZhbDsKQEAgLTU0MSwxMCArNTY1LDE0IEBACiAKIAlmb3IgKGkgPSAwOyBpIDwgcGlwZXNfbnVtOyBpKyspIHsKIAkJaW54ID0gaSArIGZpcnN0X3BpcGU7CisJCS8qCisJCSAqIEhQRCBidWZmZXIgb24gR1RUIGlzIGFsbG9jYXRlZCBieSBhbWRrZmQsIG5vIG5lZWQgdG8gd2FzdGUKKwkJICogc3BhY2UgaW4gR1RUIGZvciBwaXBlbGluZXMgd2UgZG9uJ3QgaW5pdGlhbGl6ZQorCQkgKi8KIAkJcGlwZV9ocGRfYWRkciA9IGRxbS0+cGlwZWxpbmVzX2FkZHIgKyBpICogQ0lLX0hQRF9FT1BfQllURVM7CiAJCXByX2RlYnVnKCJrZmQ6IHBpcGVsaW5lIGFkZHJlc3MgJWxsWFxuIiwgcGlwZV9ocGRfYWRkcik7CiAJCS8qID0gbG9nMihieXRlcy80KS0xICovCi0JCWtmZDJrZ2QtPmluaXRfcGlwZWxpbmUoZHFtLT5kZXYtPmtnZCwgaSwKKwkJa2ZkMmtnZC0+aW5pdF9waXBlbGluZShkcW0tPmRldi0+a2dkLCBpbngsCiAJCQkJQ0lLX0hQRF9FT1BfQllURVNfTE9HMiAtIDMsIHBpcGVfaHBkX2FkZHIpOwogCX0KIApAQCAtNTYwLDcgKzU4OCw3IEBACiAKIAlwcl9kZWJ1Zygia2ZkOiBJbiAlc1xuIiwgX19mdW5jX18pOwogCi0JcmV0dmFsID0gaW5pdF9waXBlbGluZXMoZHFtLCBnZXRfcGlwZXNfbnVtKGRxbSksIEtGRF9EUU1fRklSU1RfUElQRSk7CisJcmV0dmFsID0gaW5pdF9waXBlbGluZXMoZHFtLCBnZXRfcGlwZXNfbnVtKGRxbSksIGdldF9maXJzdF9waXBlKGRxbSkpOwogCWlmIChyZXR2YWwgIT0gMCkKIAkJcmV0dXJuIHJldHZhbDsKIApAQCAtNzUyLDYgKzc4MCwyMSBAQAogCXByX2RlYnVnKCJrZmQ6IEluIGZ1bmMgJXNcbiIsIF9fZnVuY19fKTsKIAogCW11dGV4X2xvY2soJmRxbS0+bG9jayk7CisJaWYgKGRxbS0+dG90YWxfcXVldWVfY291bnQgPj0gbWF4X251bV9vZl9xdWV1ZXNfcGVyX2RldmljZSkgeworCQlwcl93YXJuKCJhbWRrZmQ6IENhbid0IGNyZWF0ZSBuZXcga2VybmVsIHF1ZXVlIGJlY2F1c2UgJWQgcXVldWVzIHdlcmUgYWxyZWFkeSBjcmVhdGVkXG4iLAorCQkJCWRxbS0+dG90YWxfcXVldWVfY291bnQpOworCQltdXRleF91bmxvY2soJmRxbS0+bG9jayk7CisJCXJldHVybiAtRVBFUk07CisJfQorCisJLyoKKwkgKiBVbmNvbmRpdGlvbmFsbHkgaW5jcmVtZW50IHRoaXMgY291bnRlciwgcmVnYXJkbGVzcyBvZiB0aGUgcXVldWUncworCSAqIHR5cGUgb3Igd2hldGhlciB0aGUgcXVldWUgaXMgYWN0aXZlLgorCSAqLworCWRxbS0+dG90YWxfcXVldWVfY291bnQrKzsKKwlwcl9kZWJ1ZygiVG90YWwgb2YgJWQgcXVldWVzIGFyZSBhY2NvdW50YWJsZSBzbyBmYXJcbiIsCisJCQlkcW0tPnRvdGFsX3F1ZXVlX2NvdW50KTsKKwogCWxpc3RfYWRkKCZrcS0+bGlzdCwgJnFwZC0+cHJpdl9xdWV1ZV9saXN0KTsKIAlkcW0tPnF1ZXVlX2NvdW50Kys7CiAJcXBkLT5pc19kZWJ1ZyA9IHRydWU7CkBAIC03NzUsNiArODE4LDEzIEBACiAJZHFtLT5xdWV1ZV9jb3VudC0tOwogCXFwZC0+aXNfZGVidWcgPSBmYWxzZTsKIAlleGVjdXRlX3F1ZXVlc19jcHNjaChkcW0sIGZhbHNlKTsKKwkvKgorCSAqIFVuY29uZGl0aW9uYWxseSBkZWNyZW1lbnQgdGhpcyBjb3VudGVyLCByZWdhcmRsZXNzIG9mIHRoZSBxdWV1ZSdzCisJICogdHlwZS4KKwkgKi8KKwlkcW0tPnRvdGFsX3F1ZXVlX2NvdW50LS07CisJcHJfZGVidWcoIlRvdGFsIG9mICVkIHF1ZXVlcyBhcmUgYWNjb3VudGFibGUgc28gZmFyXG4iLAorCQkJZHFtLT50b3RhbF9xdWV1ZV9jb3VudCk7CiAJbXV0ZXhfdW5sb2NrKCZkcW0tPmxvY2spOwogfQogCkBAIC03OTMsNiArODQzLDEzIEBACiAKIAltdXRleF9sb2NrKCZkcW0tPmxvY2spOwogCisJaWYgKGRxbS0+dG90YWxfcXVldWVfY291bnQgPj0gbWF4X251bV9vZl9xdWV1ZXNfcGVyX2RldmljZSkgeworCQlwcl93YXJuKCJhbWRrZmQ6IENhbid0IGNyZWF0ZSBuZXcgdXNlcm1vZGUgcXVldWUgYmVjYXVzZSAlZCBxdWV1ZXMgd2VyZSBhbHJlYWR5IGNyZWF0ZWRcbiIsCisJCQkJZHFtLT50b3RhbF9xdWV1ZV9jb3VudCk7CisJCXJldHZhbCA9IC1FUEVSTTsKKwkJZ290byBvdXQ7CisJfQorCiAJbXFkID0gZHFtLT5nZXRfbXFkX21hbmFnZXIoZHFtLCBLRkRfTVFEX1RZUEVfQ0lLX0NQKTsKIAlpZiAobXFkID09IE5VTEwpIHsKIAkJbXV0ZXhfdW5sb2NrKCZkcW0tPmxvY2spOwpAQCAtODEwLDYgKzg2NywxNSBAQAogCQlyZXR2YWwgPSBleGVjdXRlX3F1ZXVlc19jcHNjaChkcW0sIGZhbHNlKTsKIAl9CiAKKwkvKgorCSAqIFVuY29uZGl0aW9uYWxseSBpbmNyZW1lbnQgdGhpcyBjb3VudGVyLCByZWdhcmRsZXNzIG9mIHRoZSBxdWV1ZSdzCisJICogdHlwZSBvciB3aGV0aGVyIHRoZSBxdWV1ZSBpcyBhY3RpdmUuCisJICovCisJZHFtLT50b3RhbF9xdWV1ZV9jb3VudCsrOworCisJcHJfZGVidWcoIlRvdGFsIG9mICVkIHF1ZXVlcyBhcmUgYWNjb3VudGFibGUgc28gZmFyXG4iLAorCQkJZHFtLT50b3RhbF9xdWV1ZV9jb3VudCk7CisKIG91dDoKIAltdXRleF91bmxvY2soJmRxbS0+bG9jayk7CiAJcmV0dXJuIHJldHZhbDsKQEAgLTkzMCw2ICs5OTYsMTQgQEAKIAogCW1xZC0+dW5pbml0X21xZChtcWQsIHEtPm1xZCwgcS0+bXFkX21lbV9vYmopOwogCisJLyoKKwkgKiBVbmNvbmRpdGlvbmFsbHkgZGVjcmVtZW50IHRoaXMgY291bnRlciwgcmVnYXJkbGVzcyBvZiB0aGUgcXVldWUncworCSAqIHR5cGUKKwkgKi8KKwlkcW0tPnRvdGFsX3F1ZXVlX2NvdW50LS07CisJcHJfZGVidWcoIlRvdGFsIG9mICVkIHF1ZXVlcyBhcmUgYWNjb3VudGFibGUgc28gZmFyXG4iLAorCQkJZHFtLT50b3RhbF9xdWV1ZV9jb3VudCk7CisKIAltdXRleF91bmxvY2soJmRxbS0+bG9jayk7CiAKIAlyZXR1cm4gMDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1ka2ZkL2tmZF9kZXZpY2VfcXVldWVfbWFuYWdlci5oIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRrZmQva2ZkX2RldmljZV9xdWV1ZV9tYW5hZ2VyLmgKaW5kZXggYzNmMTg5ZTguLjUyMDM1YmYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1ka2ZkL2tmZF9kZXZpY2VfcXVldWVfbWFuYWdlci5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1ka2ZkL2tmZF9kZXZpY2VfcXVldWVfbWFuYWdlci5oCkBAIC0xMzAsNiArMTMwLDcgQEAKIAlzdHJ1Y3QgbGlzdF9oZWFkCXF1ZXVlczsKIAl1bnNpZ25lZCBpbnQJCXByb2Nlc3Nlc19jb3VudDsKIAl1bnNpZ25lZCBpbnQJCXF1ZXVlX2NvdW50OworCXVuc2lnbmVkIGludAkJdG90YWxfcXVldWVfY291bnQ7CiAJdW5zaWduZWQgaW50CQluZXh0X3BpcGVfdG9fYWxsb2NhdGU7CiAJdW5zaWduZWQgaW50CQkqYWxsb2NhdGVkX3F1ZXVlczsKIAl1bnNpZ25lZCBpbnQJCXZtaWRfYml0bWFwOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRrZmQva2ZkX2ludGVycnVwdC5jIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRrZmQva2ZkX2ludGVycnVwdC5jCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA1Yjk5OTA5Li4wMDAwMDAwCi0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1ka2ZkL2tmZF9pbnRlcnJ1cHQuYworKysgL2Rldi9udWxsCkBAIC0xLDE3NiArMCwwIEBACi0vKgotICogQ29weXJpZ2h0IDIwMTQgQWR2YW5jZWQgTWljcm8gRGV2aWNlcywgSW5jLgotICoKLSAqIFBlcm1pc3Npb24gaXMgaGVyZWJ5IGdyYW50ZWQsIGZyZWUgb2YgY2hhcmdlLCB0byBhbnkgcGVyc29uIG9idGFpbmluZyBhCi0gKiBjb3B5IG9mIHRoaXMgc29mdHdhcmUgYW5kIGFzc29jaWF0ZWQgZG9jdW1lbnRhdGlvbiBmaWxlcyAodGhlICJTb2Z0d2FyZSIpLAotICogdG8gZGVhbCBpbiB0aGUgU29mdHdhcmUgd2l0aG91dCByZXN0cmljdGlvbiwgaW5jbHVkaW5nIHdpdGhvdXQgbGltaXRhdGlvbgotICogdGhlIHJpZ2h0cyB0byB1c2UsIGNvcHksIG1vZGlmeSwgbWVyZ2UsIHB1Ymxpc2gsIGRpc3RyaWJ1dGUsIHN1YmxpY2Vuc2UsCi0gKiBhbmQvb3Igc2VsbCBjb3BpZXMgb2YgdGhlIFNvZnR3YXJlLCBhbmQgdG8gcGVybWl0IHBlcnNvbnMgdG8gd2hvbSB0aGUKLSAqIFNvZnR3YXJlIGlzIGZ1cm5pc2hlZCB0byBkbyBzbywgc3ViamVjdCB0byB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnM6Ci0gKgotICogVGhlIGFib3ZlIGNvcHlyaWdodCBub3RpY2UgYW5kIHRoaXMgcGVybWlzc2lvbiBub3RpY2Ugc2hhbGwgYmUgaW5jbHVkZWQgaW4KLSAqIGFsbCBjb3BpZXMgb3Igc3Vic3RhbnRpYWwgcG9ydGlvbnMgb2YgdGhlIFNvZnR3YXJlLgotICoKLSAqIFRIRSBTT0ZUV0FSRSBJUyBQUk9WSURFRCAiQVMgSVMiLCBXSVRIT1VUIFdBUlJBTlRZIE9GIEFOWSBLSU5ELCBFWFBSRVNTIE9SCi0gKiBJTVBMSUVELCBJTkNMVURJTkcgQlVUIE5PVCBMSU1JVEVEIFRPIFRIRSBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSwKLSAqIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFORCBOT05JTkZSSU5HRU1FTlQuICBJTiBOTyBFVkVOVCBTSEFMTAotICogVEhFIENPUFlSSUdIVCBIT0xERVIoUykgT1IgQVVUSE9SKFMpIEJFIExJQUJMRSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VTIE9SCi0gKiBPVEhFUiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQU4gQUNUSU9OIE9GIENPTlRSQUNULCBUT1JUIE9SIE9USEVSV0lTRSwKLSAqIEFSSVNJTkcgRlJPTSwgT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdBUkUgT1IgVEhFIFVTRSBPUgotICogT1RIRVIgREVBTElOR1MgSU4gVEhFIFNPRlRXQVJFLgotICovCi0KLS8qCi0gKiBLRkQgSW50ZXJydXB0cy4KLSAqCi0gKiBBTUQgR1BVcyBkZWxpdmVyIGludGVycnVwdHMgYnkgcHVzaGluZyBhbiBpbnRlcnJ1cHQgZGVzY3JpcHRpb24gb250byB0aGUKLSAqIGludGVycnVwdCByaW5nIGFuZCB0aGVuIHNlbmRpbmcgYW4gaW50ZXJydXB0LiBLR0QgcmVjZWl2ZXMgdGhlIGludGVycnVwdAotICogaW4gSVNSIGFuZCBzZW5kcyB1cyBhIHBvaW50ZXIgdG8gZWFjaCBuZXcgZW50cnkgb24gdGhlIGludGVycnVwdCByaW5nLgotICoKLSAqIFdlIGdlbmVyYWxseSBjYW4ndCBwcm9jZXNzIGludGVycnVwdC1zaWduYWxlZCBldmVudHMgZnJvbSBJU1IsIHNvIHdlIGNhbGwKLSAqIG91dCB0byBlYWNoIGludGVycnVwdCBjbGllbnQgbW9kdWxlIChjdXJyZW50bHkgb25seSB0aGUgc2NoZWR1bGVyKSB0byBhc2sgaWYKLSAqIGVhY2ggaW50ZXJydXB0IGlzIGludGVyZXN0aW5nLiBJZiB0aGV5IHJldHVybiB0cnVlLCB0aGVuIGl0IHJlcXVpcmVzIGZ1cnRoZXIKLSAqIHByb2Nlc3Npbmcgc28gd2UgY29weSBpdCB0byBhbiBpbnRlcm5hbCBpbnRlcnJ1cHQgcmluZyBhbmQgY2FsbCBlYWNoCi0gKiBpbnRlcnJ1cHQgY2xpZW50IGFnYWluIGZyb20gYSB3b3JrLXF1ZXVlLgotICoKLSAqIFRoZXJlJ3Mgbm8gYWNrbm93bGVkZ21lbnQgZm9yIHRoZSBpbnRlcnJ1cHRzIHdlIHVzZS4gVGhlIGhhcmR3YXJlIHNpbXBseQotICogcXVldWVzIGEgbmV3IGludGVycnVwdCBlYWNoIHRpbWUgd2l0aG91dCB3YWl0aW5nLgotICoKLSAqIFRoZSBmaXhlZC1zaXplIGludGVybmFsIHF1ZXVlIG1lYW5zIHRoYXQgaXQncyBwb3NzaWJsZSBmb3IgdXMgdG8gbG9zZQotICogaW50ZXJydXB0cyBiZWNhdXNlIHdlIGhhdmUgbm8gYmFjay1wcmVzc3VyZSB0byB0aGUgaGFyZHdhcmUuCi0gKi8KLQotI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KLSNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KLSNpbmNsdWRlICJrZmRfcHJpdi5oIgotCi0jZGVmaW5lIEtGRF9JTlRFUlJVUFRfUklOR19TSVpFIDI1NgotCi1zdGF0aWMgdm9pZCBpbnRlcnJ1cHRfd3Eoc3RydWN0IHdvcmtfc3RydWN0ICopOwotCi1pbnQga2ZkX2ludGVycnVwdF9pbml0KHN0cnVjdCBrZmRfZGV2ICprZmQpCi17Ci0Jdm9pZCAqaW50ZXJydXB0X3JpbmcgPSBrbWFsbG9jX2FycmF5KEtGRF9JTlRFUlJVUFRfUklOR19TSVpFLAotCQkJCQlrZmQtPmRldmljZV9pbmZvLT5paF9yaW5nX2VudHJ5X3NpemUsCi0JCQkJCUdGUF9LRVJORUwpOwotCWlmICghaW50ZXJydXB0X3JpbmcpCi0JCXJldHVybiAtRU5PTUVNOwotCi0Ja2ZkLT5pbnRlcnJ1cHRfcmluZyA9IGludGVycnVwdF9yaW5nOwotCWtmZC0+aW50ZXJydXB0X3Jpbmdfc2l6ZSA9Ci0JCUtGRF9JTlRFUlJVUFRfUklOR19TSVpFICoga2ZkLT5kZXZpY2VfaW5mby0+aWhfcmluZ19lbnRyeV9zaXplOwotCWF0b21pY19zZXQoJmtmZC0+aW50ZXJydXB0X3Jpbmdfd3B0ciwgMCk7Ci0JYXRvbWljX3NldCgma2ZkLT5pbnRlcnJ1cHRfcmluZ19ycHRyLCAwKTsKLQotCXNwaW5fbG9ja19pbml0KCZrZmQtPmludGVycnVwdF9sb2NrKTsKLQotCUlOSVRfV09SSygma2ZkLT5pbnRlcnJ1cHRfd29yaywgaW50ZXJydXB0X3dxKTsKLQotCWtmZC0+aW50ZXJydXB0c19hY3RpdmUgPSB0cnVlOwotCi0JLyoKLQkgKiBBZnRlciB0aGlzIGZ1bmN0aW9uIHJldHVybnMsIHRoZSBpbnRlcnJ1cHQgd2lsbCBiZSBlbmFibGVkLiBUaGlzCi0JICogYmFycmllciBlbnN1cmVzIHRoYXQgdGhlIGludGVycnVwdCBydW5uaW5nIG9uIGEgZGlmZmVyZW50IHByb2Nlc3NvcgotCSAqIHNlZXMgYWxsIHRoZSBhYm92ZSB3cml0ZXMuCi0JICovCi0Jc21wX3dtYigpOwotCi0JcmV0dXJuIDA7Ci19Ci0KLXZvaWQga2ZkX2ludGVycnVwdF9leGl0KHN0cnVjdCBrZmRfZGV2ICprZmQpCi17Ci0JLyoKLQkgKiBTdG9wIHRoZSBpbnRlcnJ1cHQgaGFuZGxlciBmcm9tIHdyaXRpbmcgdG8gdGhlIHJpbmcgYW5kIHNjaGVkdWxpbmcKLQkgKiB3b3JrcXVldWUgaXRlbXMuIFRoZSBzcGlubG9jayBlbnN1cmVzIHRoYXQgYW55IGludGVycnVwdCBydW5uaW5nCi0JICogYWZ0ZXIgd2UgaGF2ZSB1bmxvY2tlZCBzZWVzIGludGVycnVwdHNfYWN0aXZlID0gZmFsc2UuCi0JICovCi0JdW5zaWduZWQgbG9uZyBmbGFnczsKLQotCXNwaW5fbG9ja19pcnFzYXZlKCZrZmQtPmludGVycnVwdF9sb2NrLCBmbGFncyk7Ci0Ja2ZkLT5pbnRlcnJ1cHRzX2FjdGl2ZSA9IGZhbHNlOwotCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmtmZC0+aW50ZXJydXB0X2xvY2ssIGZsYWdzKTsKLQotCS8qCi0JICogRmx1c2hfc2NoZWR1bGVkX3dvcmsgZW5zdXJlcyB0aGF0IHRoZXJlIGFyZSBubyBvdXRzdGFuZGluZwotCSAqIHdvcmstcXVldWUgaXRlbXMgdGhhdCB3aWxsIGFjY2VzcyBpbnRlcnJ1cHRfcmluZy4gTmV3IHdvcmsgaXRlbXMKLQkgKiBjYW4ndCBiZSBjcmVhdGVkIGJlY2F1c2Ugd2Ugc3RvcHBlZCBpbnRlcnJ1cHQgaGFuZGxpbmcgYWJvdmUuCi0JICovCi0JZmx1c2hfc2NoZWR1bGVkX3dvcmsoKTsKLQotCWtmcmVlKGtmZC0+aW50ZXJydXB0X3JpbmcpOwotfQotCi0vKgotICogVGhpcyBhc3N1bWVzIHRoYXQgaXQgY2FuJ3QgYmUgY2FsbGVkIGNvbmN1cnJlbnRseSB3aXRoIGl0c2VsZgotICogYnV0IG9ubHkgd2l0aCBkZXF1ZXVlX2loX3JpbmdfZW50cnkuCi0gKi8KLWJvb2wgZW5xdWV1ZV9paF9yaW5nX2VudHJ5KHN0cnVjdCBrZmRfZGV2ICprZmQsCWNvbnN0IHZvaWQgKmloX3JpbmdfZW50cnkpCi17Ci0JdW5zaWduZWQgaW50IHJwdHIgPSBhdG9taWNfcmVhZCgma2ZkLT5pbnRlcnJ1cHRfcmluZ19ycHRyKTsKLQl1bnNpZ25lZCBpbnQgd3B0ciA9IGF0b21pY19yZWFkKCZrZmQtPmludGVycnVwdF9yaW5nX3dwdHIpOwotCi0JaWYgKChycHRyIC0gd3B0cikgJSBrZmQtPmludGVycnVwdF9yaW5nX3NpemUgPT0KLQkJCQkJa2ZkLT5kZXZpY2VfaW5mby0+aWhfcmluZ19lbnRyeV9zaXplKSB7Ci0JCS8qIFRoaXMgaXMgdmVyeSBiYWQsIHRoZSBzeXN0ZW0gaXMgbGlrZWx5IHRvIGhhbmcuICovCi0JCWRldl9lcnJfcmF0ZWxpbWl0ZWQoa2ZkX2NoYXJkZXYoKSwKLQkJCSJJbnRlcnJ1cHQgcmluZyBvdmVyZmxvdywgZHJvcHBpbmcgaW50ZXJydXB0LlxuIik7Ci0JCXJldHVybiBmYWxzZTsKLQl9Ci0KLQltZW1jcHkoa2ZkLT5pbnRlcnJ1cHRfcmluZyArIHdwdHIsIGloX3JpbmdfZW50cnksCi0JCQlrZmQtPmRldmljZV9pbmZvLT5paF9yaW5nX2VudHJ5X3NpemUpOwotCi0Jd3B0ciA9ICh3cHRyICsga2ZkLT5kZXZpY2VfaW5mby0+aWhfcmluZ19lbnRyeV9zaXplKSAlCi0JCQlrZmQtPmludGVycnVwdF9yaW5nX3NpemU7Ci0Jc21wX3dtYigpOyAvKiBFbnN1cmUgbWVtY3B5J2QgZGF0YSBpcyB2aXNpYmxlIGJlZm9yZSB3cHRyIHVwZGF0ZS4gKi8KLQlhdG9taWNfc2V0KCZrZmQtPmludGVycnVwdF9yaW5nX3dwdHIsIHdwdHIpOwotCi0JcmV0dXJuIHRydWU7Ci19Ci0KLS8qCi0gKiBUaGlzIGFzc3VtZXMgdGhhdCBpdCBjYW4ndCBiZSBjYWxsZWQgY29uY3VycmVudGx5IHdpdGggaXRzZWxmCi0gKiBidXQgb25seSB3aXRoIGVucXVldWVfaWhfcmluZ19lbnRyeS4KLSAqLwotc3RhdGljIGJvb2wgZGVxdWV1ZV9paF9yaW5nX2VudHJ5KHN0cnVjdCBrZmRfZGV2ICprZmQsIHZvaWQgKmloX3JpbmdfZW50cnkpCi17Ci0JLyoKLQkgKiBBc3N1bWUgdGhhdCB3YWl0IHF1ZXVlcyBoYXZlIGFuIGltcGxpY2l0IGJhcnJpZXIsIGkuZS4gYW55dGhpbmcgdGhhdAotCSAqIGhhcHBlbmVkIGluIHRoZSBJU1IgYmVmb3JlIGl0IHF1ZXVlZCB3b3JrIGlzIHZpc2libGUuCi0JICovCi0KLQl1bnNpZ25lZCBpbnQgd3B0ciA9IGF0b21pY19yZWFkKCZrZmQtPmludGVycnVwdF9yaW5nX3dwdHIpOwotCXVuc2lnbmVkIGludCBycHRyID0gYXRvbWljX3JlYWQoJmtmZC0+aW50ZXJydXB0X3JpbmdfcnB0cik7Ci0KLQlpZiAocnB0ciA9PSB3cHRyKQotCQlyZXR1cm4gZmFsc2U7Ci0KLQltZW1jcHkoaWhfcmluZ19lbnRyeSwga2ZkLT5pbnRlcnJ1cHRfcmluZyArIHJwdHIsCi0JCQlrZmQtPmRldmljZV9pbmZvLT5paF9yaW5nX2VudHJ5X3NpemUpOwotCi0JcnB0ciA9IChycHRyICsga2ZkLT5kZXZpY2VfaW5mby0+aWhfcmluZ19lbnRyeV9zaXplKSAlCi0JCQlrZmQtPmludGVycnVwdF9yaW5nX3NpemU7Ci0KLQkvKgotCSAqIEVuc3VyZSB0aGUgcnB0ciB3cml0ZSB1cGRhdGUgaXMgbm90IHZpc2libGUgdW50aWwKLQkgKiBtZW1jcHkgaGFzIGZpbmlzaGVkIHJlYWRpbmcuCi0JICovCi0Jc21wX21iKCk7Ci0JYXRvbWljX3NldCgma2ZkLT5pbnRlcnJ1cHRfcmluZ19ycHRyLCBycHRyKTsKLQotCXJldHVybiB0cnVlOwotfQotCi1zdGF0aWMgdm9pZCBpbnRlcnJ1cHRfd3Eoc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQotewotCXN0cnVjdCBrZmRfZGV2ICpkZXYgPSBjb250YWluZXJfb2Yod29yaywgc3RydWN0IGtmZF9kZXYsCi0JCQkJCQlpbnRlcnJ1cHRfd29yayk7Ci0KLQl1aW50MzJfdCBpaF9yaW5nX2VudHJ5W0RJVl9ST1VORF9VUCgKLQkJCQlkZXYtPmRldmljZV9pbmZvLT5paF9yaW5nX2VudHJ5X3NpemUsCi0JCQkJc2l6ZW9mKHVpbnQzMl90KSldOwotCi0Jd2hpbGUgKGRlcXVldWVfaWhfcmluZ19lbnRyeShkZXYsIGloX3JpbmdfZW50cnkpKQotCQk7Ci19CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGtmZC9rZmRfbW9kdWxlLmMgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGtmZC9rZmRfbW9kdWxlLmMKaW5kZXggOTVkNWFmMS4uMWMzODVjMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRrZmQva2ZkX21vZHVsZS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1ka2ZkL2tmZF9tb2R1bGUuYwpAQCAtNTAsMTUgKzUwLDEwIEBACiBNT0RVTEVfUEFSTV9ERVNDKHNjaGVkX3BvbGljeSwKIAkiS2VybmVsIGNtZGxpbmUgcGFyYW1ldGVyIHRoYXQgZGVmaW5lcyB0aGUgYW1ka2ZkIHNjaGVkdWxpbmcgcG9saWN5Iik7CiAKLWludCBtYXhfbnVtX29mX3Byb2Nlc3NlcyA9IEtGRF9NQVhfTlVNX09GX1BST0NFU1NFU19ERUZBVUxUOwotbW9kdWxlX3BhcmFtKG1heF9udW1fb2ZfcHJvY2Vzc2VzLCBpbnQsIDA0NDQpOwotTU9EVUxFX1BBUk1fREVTQyhtYXhfbnVtX29mX3Byb2Nlc3NlcywKLQkiS2VybmVsIGNtZGxpbmUgcGFyYW1ldGVyIHRoYXQgZGVmaW5lcyB0aGUgYW1ka2ZkIG1heGltdW0gbnVtYmVyIG9mIHN1cHBvcnRlZCBwcm9jZXNzZXMiKTsKLQotaW50IG1heF9udW1fb2ZfcXVldWVzX3Blcl9wcm9jZXNzID0gS0ZEX01BWF9OVU1fT0ZfUVVFVUVTX1BFUl9QUk9DRVNTX0RFRkFVTFQ7Ci1tb2R1bGVfcGFyYW0obWF4X251bV9vZl9xdWV1ZXNfcGVyX3Byb2Nlc3MsIGludCwgMDQ0NCk7Ci1NT0RVTEVfUEFSTV9ERVNDKG1heF9udW1fb2ZfcXVldWVzX3Blcl9wcm9jZXNzLAotCSJLZXJuZWwgY21kbGluZSBwYXJhbWV0ZXIgdGhhdCBkZWZpbmVzIHRoZSBhbWRrZmQgbWF4aW11bSBudW1iZXIgb2Ygc3VwcG9ydGVkIHF1ZXVlcyBwZXIgcHJvY2VzcyIpOworaW50IG1heF9udW1fb2ZfcXVldWVzX3Blcl9kZXZpY2UgPSBLRkRfTUFYX05VTV9PRl9RVUVVRVNfUEVSX0RFVklDRV9ERUZBVUxUOworbW9kdWxlX3BhcmFtKG1heF9udW1fb2ZfcXVldWVzX3Blcl9kZXZpY2UsIGludCwgMDQ0NCk7CitNT0RVTEVfUEFSTV9ERVNDKG1heF9udW1fb2ZfcXVldWVzX3Blcl9kZXZpY2UsCisJIk1heGltdW0gbnVtYmVyIG9mIHN1cHBvcnRlZCBxdWV1ZXMgcGVyIGRldmljZSAoMSA9IE1pbmltdW0sIDQwOTYgPSBkZWZhdWx0KSIpOwogCiBib29sIGtnZDJrZmRfaW5pdCh1bnNpZ25lZCBpbnRlcmZhY2VfdmVyc2lvbiwKIAkJICBjb25zdCBzdHJ1Y3Qga2ZkMmtnZF9jYWxscyAqZjJnLApAQCAtMTAwLDE2ICs5NSwxMCBAQAogCX0KIAogCS8qIFZlcmlmeSBtb2R1bGUgcGFyYW1ldGVycyAqLwotCWlmICgobWF4X251bV9vZl9wcm9jZXNzZXMgPCAwKSB8fAotCQkobWF4X251bV9vZl9wcm9jZXNzZXMgPiBLRkRfTUFYX05VTV9PRl9QUk9DRVNTRVMpKSB7Ci0JCXByX2Vycigia2ZkOiBtYXhfbnVtX29mX3Byb2Nlc3NlcyBtdXN0IGJlIGJldHdlZW4gMCB0byBLRkRfTUFYX05VTV9PRl9QUk9DRVNTRVNcbiIpOwotCQlyZXR1cm4gLTE7Ci0JfQotCi0JaWYgKChtYXhfbnVtX29mX3F1ZXVlc19wZXJfcHJvY2VzcyA8IDApIHx8Ci0JCShtYXhfbnVtX29mX3F1ZXVlc19wZXJfcHJvY2VzcyA+Ci0JCQlLRkRfTUFYX05VTV9PRl9RVUVVRVNfUEVSX1BST0NFU1MpKSB7Ci0JCXByX2Vycigia2ZkOiBtYXhfbnVtX29mX3F1ZXVlc19wZXJfcHJvY2VzcyBtdXN0IGJlIGJldHdlZW4gMCB0byBLRkRfTUFYX05VTV9PRl9RVUVVRVNfUEVSX1BST0NFU1NcbiIpOworCWlmICgobWF4X251bV9vZl9xdWV1ZXNfcGVyX2RldmljZSA8IDEpIHx8CisJCShtYXhfbnVtX29mX3F1ZXVlc19wZXJfZGV2aWNlID4KKwkJCUtGRF9NQVhfTlVNX09GX1FVRVVFU19QRVJfREVWSUNFKSkgeworCQlwcl9lcnIoImtmZDogbWF4X251bV9vZl9xdWV1ZXNfcGVyX2RldmljZSBtdXN0IGJlIGJldHdlZW4gMSB0byBLRkRfTUFYX05VTV9PRl9RVUVVRVNfUEVSX0RFVklDRVxuIik7CiAJCXJldHVybiAtMTsKIAl9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1ka2ZkL2tmZF9wYXNpZC5jIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRrZmQva2ZkX3Bhc2lkLmMKaW5kZXggNGMyNWVmNS4uNmNmZTdmMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRrZmQva2ZkX3Bhc2lkLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRrZmQva2ZkX3Bhc2lkLmMKQEAgLTMwLDcgKzMwLDcgQEAKIAogaW50IGtmZF9wYXNpZF9pbml0KHZvaWQpCiB7Ci0JcGFzaWRfbGltaXQgPSBtYXhfbnVtX29mX3Byb2Nlc3NlczsKKwlwYXNpZF9saW1pdCA9IEtGRF9NQVhfTlVNX09GX1BST0NFU1NFUzsKIAogCXBhc2lkX2JpdG1hcCA9IGtjYWxsb2MoQklUU19UT19MT05HUyhwYXNpZF9saW1pdCksIHNpemVvZihsb25nKSwgR0ZQX0tFUk5FTCk7CiAJaWYgKCFwYXNpZF9iaXRtYXApCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGtmZC9rZmRfcHJpdi5oIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRrZmQva2ZkX3ByaXYuaAppbmRleCBhNWVkYjI5Li45NmRjMTBlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGtmZC9rZmRfcHJpdi5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1ka2ZkL2tmZF9wcml2LmgKQEAgLTUyLDIwICs1MiwxOSBAQAogI2RlZmluZSBrZmRfYWxsb2Nfc3RydWN0KHB0cl90b19zdHJ1Y3QpCVwKIAkoKHR5cGVvZihwdHJfdG9fc3RydWN0KSkga3phbGxvYyhzaXplb2YoKnB0cl90b19zdHJ1Y3QpLCBHRlBfS0VSTkVMKSkKIAotLyogS2VybmVsIG1vZHVsZSBwYXJhbWV0ZXIgdG8gc3BlY2lmeSBtYXhpbXVtIG51bWJlciBvZiBzdXBwb3J0ZWQgcHJvY2Vzc2VzICovCi1leHRlcm4gaW50IG1heF9udW1fb2ZfcHJvY2Vzc2VzOwotCi0jZGVmaW5lIEtGRF9NQVhfTlVNX09GX1BST0NFU1NFU19ERUZBVUxUIDMyCiAjZGVmaW5lIEtGRF9NQVhfTlVNX09GX1BST0NFU1NFUyA1MTIKKyNkZWZpbmUgS0ZEX01BWF9OVU1fT0ZfUVVFVUVTX1BFUl9QUk9DRVNTIDEwMjQKIAogLyoKLSAqIEtlcm5lbCBtb2R1bGUgcGFyYW1ldGVyIHRvIHNwZWNpZnkgbWF4aW11bSBudW1iZXIgb2Ygc3VwcG9ydGVkIHF1ZXVlcwotICogcGVyIHByb2Nlc3MKKyAqIEtlcm5lbCBtb2R1bGUgcGFyYW1ldGVyIHRvIHNwZWNpZnkgbWF4aW11bSBudW1iZXIgb2Ygc3VwcG9ydGVkIHF1ZXVlcyBwZXIKKyAqIGRldmljZQogICovCi1leHRlcm4gaW50IG1heF9udW1fb2ZfcXVldWVzX3Blcl9wcm9jZXNzOworZXh0ZXJuIGludCBtYXhfbnVtX29mX3F1ZXVlc19wZXJfZGV2aWNlOwogCi0jZGVmaW5lIEtGRF9NQVhfTlVNX09GX1FVRVVFU19QRVJfUFJPQ0VTU19ERUZBVUxUIDEyOAotI2RlZmluZSBLRkRfTUFYX05VTV9PRl9RVUVVRVNfUEVSX1BST0NFU1MgMTAyNAorI2RlZmluZSBLRkRfTUFYX05VTV9PRl9RVUVVRVNfUEVSX0RFVklDRV9ERUZBVUxUIDQwOTYKKyNkZWZpbmUgS0ZEX01BWF9OVU1fT0ZfUVVFVUVTX1BFUl9ERVZJQ0UJCVwKKwkoS0ZEX01BWF9OVU1fT0ZfUFJPQ0VTU0VTICoJCQlcCisJCQlLRkRfTUFYX05VTV9PRl9RVUVVRVNfUEVSX1BST0NFU1MpCiAKICNkZWZpbmUgS0ZEX0tFUk5FTF9RVUVVRV9TSVpFIDIwNDgKIApAQCAtMTM1LDIyICsxMzQsMTAgQEAKIAogCXN0cnVjdCBrZ2Qya2ZkX3NoYXJlZF9yZXNvdXJjZXMgc2hhcmVkX3Jlc291cmNlczsKIAotCXZvaWQgKmludGVycnVwdF9yaW5nOwotCXNpemVfdCBpbnRlcnJ1cHRfcmluZ19zaXplOwotCWF0b21pY190IGludGVycnVwdF9yaW5nX3JwdHI7Ci0JYXRvbWljX3QgaW50ZXJydXB0X3Jpbmdfd3B0cjsKLQlzdHJ1Y3Qgd29ya19zdHJ1Y3QgaW50ZXJydXB0X3dvcms7Ci0Jc3BpbmxvY2tfdCBpbnRlcnJ1cHRfbG9jazsKLQogCS8qIFFDTSBEZXZpY2UgaW5zdGFuY2UgKi8KIAlzdHJ1Y3QgZGV2aWNlX3F1ZXVlX21hbmFnZXIgKmRxbTsKIAogCWJvb2wgaW5pdF9jb21wbGV0ZTsKLQkvKgotCSAqIEludGVycnVwdHMgb2YgaW50ZXJlc3QgdG8gS0ZEIGFyZSBjb3BpZWQKLQkgKiBmcm9tIHRoZSBIVyByaW5nIGludG8gYSBTVyByaW5nLgotCSAqLwotCWJvb2wgaW50ZXJydXB0c19hY3RpdmU7CiB9OwogCiAvKiBLR0QyS0ZEIGNhbGxiYWNrcyAqLwpAQCAtNTMxLDEwICs1MTgsNyBAQAogc3RydWN0IGtmZF9kZXYgKmtmZF90b3BvbG9neV9lbnVtX2tmZF9kZXZpY2VzKHVpbnQ4X3QgaWR4KTsKIAogLyogSW50ZXJydXB0cyAqLwotaW50IGtmZF9pbnRlcnJ1cHRfaW5pdChzdHJ1Y3Qga2ZkX2RldiAqZGV2KTsKLXZvaWQga2ZkX2ludGVycnVwdF9leGl0KHN0cnVjdCBrZmRfZGV2ICpkZXYpOwogdm9pZCBrZ2Qya2ZkX2ludGVycnVwdChzdHJ1Y3Qga2ZkX2RldiAqa2ZkLCBjb25zdCB2b2lkICppaF9yaW5nX2VudHJ5KTsKLWJvb2wgZW5xdWV1ZV9paF9yaW5nX2VudHJ5KHN0cnVjdCBrZmRfZGV2ICprZmQsCWNvbnN0IHZvaWQgKmloX3JpbmdfZW50cnkpOwogCiAvKiBQb3dlciBNYW5hZ2VtZW50ICovCiB2b2lkIGtnZDJrZmRfc3VzcGVuZChzdHJ1Y3Qga2ZkX2RldiAqa2ZkKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1ka2ZkL2tmZF9wcm9jZXNzX3F1ZXVlX21hbmFnZXIuYyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1ka2ZkL2tmZF9wcm9jZXNzX3F1ZXVlX21hbmFnZXIuYwppbmRleCA0NzUyNjc4Li4yZmRhMTkyNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRrZmQva2ZkX3Byb2Nlc3NfcXVldWVfbWFuYWdlci5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1ka2ZkL2tmZF9wcm9jZXNzX3F1ZXVlX21hbmFnZXIuYwpAQCAtNTQsMTEgKzU0LDExIEBACiAJcHJfZGVidWcoImtmZDogaW4gJXNcbiIsIF9fZnVuY19fKTsKIAogCWZvdW5kID0gZmluZF9maXJzdF96ZXJvX2JpdChwcW0tPnF1ZXVlX3Nsb3RfYml0bWFwLAotCQkJbWF4X251bV9vZl9xdWV1ZXNfcGVyX3Byb2Nlc3MpOworCQkJS0ZEX01BWF9OVU1fT0ZfUVVFVUVTX1BFUl9QUk9DRVNTKTsKIAogCXByX2RlYnVnKCJrZmQ6IHRoZSBuZXcgc2xvdCBpZCAlbHVcbiIsIGZvdW5kKTsKIAotCWlmIChmb3VuZCA+PSBtYXhfbnVtX29mX3F1ZXVlc19wZXJfcHJvY2VzcykgeworCWlmIChmb3VuZCA+PSBLRkRfTUFYX05VTV9PRl9RVUVVRVNfUEVSX1BST0NFU1MpIHsKIAkJcHJfaW5mbygiYW1ka2ZkOiBDYW4gbm90IG9wZW4gbW9yZSBxdWV1ZXMgZm9yIHByb2Nlc3Mgd2l0aCBwYXNpZCAlZFxuIiwKIAkJCQlwcW0tPnByb2Nlc3MtPnBhc2lkKTsKIAkJcmV0dXJuIC1FTk9NRU07CkBAIC03Niw3ICs3Niw3IEBACiAKIAlJTklUX0xJU1RfSEVBRCgmcHFtLT5xdWV1ZXMpOwogCXBxbS0+cXVldWVfc2xvdF9iaXRtYXAgPQotCQkJa3phbGxvYyhESVZfUk9VTkRfVVAobWF4X251bV9vZl9xdWV1ZXNfcGVyX3Byb2Nlc3MsCisJCQlremFsbG9jKERJVl9ST1VORF9VUChLRkRfTUFYX05VTV9PRl9RVUVVRVNfUEVSX1BST0NFU1MsCiAJCQkJCUJJVFNfUEVSX0JZVEUpLCBHRlBfS0VSTkVMKTsKIAlpZiAocHFtLT5xdWV1ZV9zbG90X2JpdG1hcCA9PSBOVUxMKQogCQlyZXR1cm4gLUVOT01FTTsKQEAgLTIwMyw2ICsyMDMsNyBAQAogCQlwcW4tPmtxID0gTlVMTDsKIAkJcmV0dmFsID0gZGV2LT5kcW0tPmNyZWF0ZV9xdWV1ZShkZXYtPmRxbSwgcSwgJnBkZC0+cXBkLAogCQkJCQkJJnEtPnByb3BlcnRpZXMudm1pZCk7CisJCXByX2RlYnVnKCJEUU0gcmV0dXJuZWQgJWQgZm9yIGNyZWF0ZV9xdWV1ZVxuIiwgcmV0dmFsKTsKIAkJcHJpbnRfcXVldWUocSk7CiAJCWJyZWFrOwogCWNhc2UgS0ZEX1FVRVVFX1RZUEVfRElROgpAQCAtMjIyLDcgKzIyMyw3IEBACiAJfQogCiAJaWYgKHJldHZhbCAhPSAwKSB7Ci0JCXByX2Vycigia2ZkOiBlcnJvciBkcW0gY3JlYXRlIHF1ZXVlXG4iKTsKKwkJcHJfZGVidWcoIkVycm9yIGRxbSBjcmVhdGUgcXVldWVcbiIpOwogCQlnb3RvIGVycl9jcmVhdGVfcXVldWU7CiAJfQogCkBAIC0yNDEsNyArMjQyLDEwIEBACiBlcnJfY3JlYXRlX3F1ZXVlOgogCWtmcmVlKHBxbik7CiBlcnJfYWxsb2NhdGVfcHFuOgorCS8qIGNoZWNrIGlmIHF1ZXVlcyBsaXN0IGlzIGVtcHR5IHVucmVnaXN0ZXIgcHJvY2VzcyBmcm9tIGRldmljZSAqLwogCWNsZWFyX2JpdCgqcWlkLCBwcW0tPnF1ZXVlX3Nsb3RfYml0bWFwKTsKKwlpZiAobGlzdF9lbXB0eSgmcHFtLT5xdWV1ZXMpKQorCQlkZXYtPmRxbS0+dW5yZWdpc3Rlcl9wcm9jZXNzKGRldi0+ZHFtLCAmcGRkLT5xcGQpOwogCXJldHVybiByZXR2YWw7CiB9CiAKQEAgLTMxMSw3ICszMTUsMTEgQEAKIAlCVUdfT04oIXBxbSk7CiAKIAlwcW4gPSBnZXRfcXVldWVfYnlfcWlkKHBxbSwgcWlkKTsKLQlCVUdfT04oIXBxbik7CisJaWYgKCFwcW4pIHsKKwkJcHJfZGVidWcoImFtZGtmZDogTm8gcXVldWUgJWQgZXhpc3RzIGZvciB1cGRhdGUgb3BlcmF0aW9uXG4iLAorCQkJCXFpZCk7CisJCXJldHVybiAtRUZBVUxUOworCX0KIAogCXBxbi0+cS0+cHJvcGVydGllcy5xdWV1ZV9hZGRyZXNzID0gcC0+cXVldWVfYWRkcmVzczsKIAlwcW4tPnEtPnByb3BlcnRpZXMucXVldWVfc2l6ZSA9IHAtPnF1ZXVlX3NpemU7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vY2lycnVzL2NpcnJ1c19kcnYuYyBiL2RyaXZlcnMvZ3B1L2RybS9jaXJydXMvY2lycnVzX2Rydi5jCmluZGV4IGMyYTFjYmEuLmI5MTQwMDMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9jaXJydXMvY2lycnVzX2Rydi5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9jaXJydXMvY2lycnVzX2Rydi5jCkBAIC0xNiw5ICsxNiwxMiBAQAogI2luY2x1ZGUgImNpcnJ1c19kcnYuaCIKIAogaW50IGNpcnJ1c19tb2Rlc2V0ID0gLTE7CitpbnQgY2lycnVzX2JwcCA9IDI0OwogCiBNT0RVTEVfUEFSTV9ERVNDKG1vZGVzZXQsICJEaXNhYmxlL0VuYWJsZSBtb2Rlc2V0dGluZyIpOwogbW9kdWxlX3BhcmFtX25hbWVkKG1vZGVzZXQsIGNpcnJ1c19tb2Rlc2V0LCBpbnQsIDA0MDApOworTU9EVUxFX1BBUk1fREVTQyhicHAsICJNYXggYml0cy1wZXItcGl4ZWwgKGRlZmF1bHQ6MjQpIik7Cittb2R1bGVfcGFyYW1fbmFtZWQoYnBwLCBjaXJydXNfYnBwLCBpbnQsIDA0MDApOwogCiAvKgogICogVGhpcyBpcyB0aGUgZ2VuZXJpYyBkcml2ZXIgY29kZS4gVGhpcyBiaW5kcyB0aGUgZHJpdmVyIHRvIHRoZSBkcm0gY29yZSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9jaXJydXMvY2lycnVzX2Rydi5oIGIvZHJpdmVycy9ncHUvZHJtL2NpcnJ1cy9jaXJydXNfZHJ2LmgKaW5kZXggNjkzYTQ1Ni4uNzA1MDYxNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2NpcnJ1cy9jaXJydXNfZHJ2LmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL2NpcnJ1cy9jaXJydXNfZHJ2LmgKQEAgLTI2Miw0ICsyNjIsNyBAQAogCiBpbnQgY2lycnVzX2JvX3B1c2hfc3lzcmFtKHN0cnVjdCBjaXJydXNfYm8gKmJvKTsKIGludCBjaXJydXNfYm9fcGluKHN0cnVjdCBjaXJydXNfYm8gKmJvLCB1MzIgcGxfZmxhZywgdTY0ICpncHVfYWRkcik7CisKK2V4dGVybiBpbnQgY2lycnVzX2JwcDsKKwogI2VuZGlmCQkJCS8qIF9fQ0lSUlVTX0RSVl9IX18gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9jaXJydXMvY2lycnVzX21haW4uYyBiL2RyaXZlcnMvZ3B1L2RybS9jaXJydXMvY2lycnVzX21haW4uYwppbmRleCA0YzJkNjhlLi5lNGI5NzY2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vY2lycnVzL2NpcnJ1c19tYWluLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2NpcnJ1cy9jaXJydXNfbWFpbi5jCkBAIC0zMjAsNiArMzIwLDggQEAKIAljb25zdCBpbnQgbWF4X3BpdGNoID0gMHgxRkYgPDwgMzsgLyogKDQwOTYgLSAxKSAmIH4xMTFiIGJ5dGVzICovCiAJY29uc3QgaW50IG1heF9zaXplID0gY2Rldi0+bWMudnJhbV9zaXplOwogCisJaWYgKGJwcCA+IGNpcnJ1c19icHApCisJCXJldHVybiBmYWxzZTsKIAlpZiAoYnBwID4gMzIpCiAJCXJldHVybiBmYWxzZTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2NpcnJ1cy9jaXJydXNfbW9kZS5jIGIvZHJpdmVycy9ncHUvZHJtL2NpcnJ1cy9jaXJydXNfbW9kZS5jCmluZGV4IDk5ZDRhNzQuLjYxMzg1ZjIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9jaXJydXMvY2lycnVzX21vZGUuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vY2lycnVzL2NpcnJ1c19tb2RlLmMKQEAgLTUwMSw4ICs1MDEsMTMgQEAKIAlpbnQgY291bnQ7CiAKIAkvKiBKdXN0IGFkZCBhIHN0YXRpYyBsaXN0IG9mIG1vZGVzICovCi0JY291bnQgPSBkcm1fYWRkX21vZGVzX25vZWRpZChjb25uZWN0b3IsIDEyODAsIDEwMjQpOwotCWRybV9zZXRfcHJlZmVycmVkX21vZGUoY29ubmVjdG9yLCAxMDI0LCA3NjgpOworCWlmIChjaXJydXNfYnBwIDw9IDI0KSB7CisJCWNvdW50ID0gZHJtX2FkZF9tb2Rlc19ub2VkaWQoY29ubmVjdG9yLCAxMjgwLCAxMDI0KTsKKwkJZHJtX3NldF9wcmVmZXJyZWRfbW9kZShjb25uZWN0b3IsIDEwMjQsIDc2OCk7CisJfSBlbHNlIHsKKwkJY291bnQgPSBkcm1fYWRkX21vZGVzX25vZWRpZChjb25uZWN0b3IsIDgwMCwgNjAwKTsKKwkJZHJtX3NldF9wcmVmZXJyZWRfbW9kZShjb25uZWN0b3IsIDgwMCwgNjAwKTsKKwl9CiAJcmV0dXJuIGNvdW50OwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2ZiX2hlbHBlci5jIGIvZHJpdmVycy9ncHUvZHJtL2RybV9mYl9oZWxwZXIuYwppbmRleCA1MmNlMjZkLi5kYzM4NmViIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2ZiX2hlbHBlci5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fZmJfaGVscGVyLmMKQEAgLTE0NSw2ICsxNDUsMzEgQEAKIH0KIEVYUE9SVF9TWU1CT0woZHJtX2ZiX2hlbHBlcl9hZGRfb25lX2Nvbm5lY3Rvcik7CiAKK3N0YXRpYyB2b2lkIHJlbW92ZV9mcm9tX21vZGVzZXQoc3RydWN0IGRybV9tb2RlX3NldCAqc2V0LAorCQlzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yKQoreworCWludCBpLCBqOworCisJZm9yIChpID0gMDsgaSA8IHNldC0+bnVtX2Nvbm5lY3RvcnM7IGkrKykgeworCQlpZiAoc2V0LT5jb25uZWN0b3JzW2ldID09IGNvbm5lY3RvcikKKwkJCWJyZWFrOworCX0KKworCWlmIChpID09IHNldC0+bnVtX2Nvbm5lY3RvcnMpCisJCXJldHVybjsKKworCWZvciAoaiA9IGkgKyAxOyBqIDwgc2V0LT5udW1fY29ubmVjdG9yczsgaisrKSB7CisJCXNldC0+Y29ubmVjdG9yc1tqIC0gMV0gPSBzZXQtPmNvbm5lY3RvcnNbal07CisJfQorCXNldC0+bnVtX2Nvbm5lY3RvcnMtLTsKKworCS8qIGJlY2F1c2UgaTkxNSBpcyBwaXNzeSBhYm91dCB0aGlzLi4KKwkgKiBUT0RPIG1heWJlIG5lZWQgdG8gbWFrZXMgc3VyZSB3ZSBzZXQgaXQgYmFjayB0byAhPU5VTEwgc29tZXdoZXJlPworCSAqLworCWlmIChzZXQtPm51bV9jb25uZWN0b3JzID09IDApCisJCXNldC0+ZmIgPSBOVUxMOworfQorCiBpbnQgZHJtX2ZiX2hlbHBlcl9yZW1vdmVfb25lX2Nvbm5lY3RvcihzdHJ1Y3QgZHJtX2ZiX2hlbHBlciAqZmJfaGVscGVyLAogCQkJCSAgICAgICBzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yKQogewpAQCAtMTY3LDYgKzE5MiwxMSBAQAogCX0KIAlmYl9oZWxwZXItPmNvbm5lY3Rvcl9jb3VudC0tOwogCWtmcmVlKGZiX2hlbHBlcl9jb25uZWN0b3IpOworCisJLyogYWxzbyBjbGVhbnVwIGRhbmdsaW5nIHJlZmVyZW5jZXMgdG8gdGhlIGNvbm5lY3RvcjogKi8KKwlmb3IgKGkgPSAwOyBpIDwgZmJfaGVscGVyLT5jcnRjX2NvdW50OyBpKyspCisJCXJlbW92ZV9mcm9tX21vZGVzZXQoJmZiX2hlbHBlci0+Y3J0Y19pbmZvW2ldLm1vZGVfc2V0LCBjb25uZWN0b3IpOworCiAJcmV0dXJuIDA7CiB9CiBFWFBPUlRfU1lNQk9MKGRybV9mYl9oZWxwZXJfcmVtb3ZlX29uZV9jb25uZWN0b3IpOwpAQCAtNzQxLDcgKzc3MSw5IEBACiAJaW50IGksIGosIHJjID0gMDsKIAlpbnQgc3RhcnQ7CiAKLQlkcm1fbW9kZXNldF9sb2NrX2FsbChkZXYpOworCWlmIChfX2RybV9tb2Rlc2V0X2xvY2tfYWxsKGRldiwgISFvb3BzX2luX3Byb2dyZXNzKSkgeworCQlyZXR1cm4gLUVCVVNZOworCX0KIAlpZiAoIWRybV9mYl9oZWxwZXJfaXNfYm91bmQoZmJfaGVscGVyKSkgewogCQlkcm1fbW9kZXNldF91bmxvY2tfYWxsKGRldik7CiAJCXJldHVybiAtRUJVU1k7CkBAIC05MTUsNyArOTQ3LDkgQEAKIAlpbnQgcmV0ID0gMDsKIAlpbnQgaTsKIAotCWRybV9tb2Rlc2V0X2xvY2tfYWxsKGRldik7CisJaWYgKF9fZHJtX21vZGVzZXRfbG9ja19hbGwoZGV2LCAhIW9vcHNfaW5fcHJvZ3Jlc3MpKSB7CisJCXJldHVybiAtRUJVU1k7CisJfQogCWlmICghZHJtX2ZiX2hlbHBlcl9pc19ib3VuZChmYl9oZWxwZXIpKSB7CiAJCWRybV9tb2Rlc2V0X3VubG9ja19hbGwoZGV2KTsKIAkJcmV0dXJuIC1FQlVTWTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9leHlub3MvZXh5bm9zX2RybV9kcnYuYyBiL2RyaXZlcnMvZ3B1L2RybS9leHlub3MvZXh5bm9zX2RybV9kcnYuYwppbmRleCAxMjE0NzBhLi4xYmNiZTA3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vZXh5bm9zL2V4eW5vc19kcm1fZHJ2LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2V4eW5vcy9leHlub3NfZHJtX2Rydi5jCkBAIC02NDUsMTggKzY0NSw2IEBACiAJaWYgKCFpc19leHlub3MpCiAJCXJldHVybiAtRU5PREVWOwogCi0JLyoKLQkgKiBSZWdpc3RlciBkZXZpY2Ugb2JqZWN0IG9ubHkgaW4gY2FzZSBvZiBFeHlub3MgU29DLgotCSAqCi0JICogQmVsb3cgY29kZXMgcmVzb2x2ZXMgdGVtcG9yYXJpbHkgaW5maW5pdGUgbG9vcCBpc3N1ZSBpbmN1cnJlZAotCSAqIGJ5IEV4eW5vcyBkcm0gZHJpdmVyIHdoZW4gdXNpbmcgbXVsdGktcGxhdGZvcm0ga2VybmVsLgotCSAqIFNvIHRoZXNlIGNvZGVzIHdpbGwgYmUgcmVwbGFjZWQgd2l0aCBtb3JlIGdlbmVyaWMgd2F5IGxhdGVyLgotCSAqLwotCWlmICghb2ZfbWFjaGluZV9pc19jb21wYXRpYmxlKCJzYW1zdW5nLGV4eW5vczMiKSAmJgotCQkJIW9mX21hY2hpbmVfaXNfY29tcGF0aWJsZSgic2Ftc3VuZyxleHlub3M0IikgJiYKLQkJCSFvZl9tYWNoaW5lX2lzX2NvbXBhdGlibGUoInNhbXN1bmcsZXh5bm9zNSIpKQotCQlyZXR1cm4gLUVOT0RFVjsKLQogCWV4eW5vc19kcm1fcGRldiA9IHBsYXRmb3JtX2RldmljZV9yZWdpc3Rlcl9zaW1wbGUoImV4eW5vcy1kcm0iLCAtMSwKIAkJCQkJCQkJTlVMTCwgMCk7CiAJaWYgKElTX0VSUihleHlub3NfZHJtX3BkZXYpKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2V4eW5vcy9leHlub3NfaGRtaS5jIGIvZHJpdmVycy9ncHUvZHJtL2V4eW5vcy9leHlub3NfaGRtaS5jCmluZGV4IDU3NjVhMTYuLjk4MDUxZTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9leHlub3MvZXh5bm9zX2hkbWkuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vZXh5bm9zL2V4eW5vc19oZG1pLmMKQEAgLTE2NjksNyArMTY2OSw2IEBACiAKIHN0YXRpYyB2b2lkIGhkbWlwaHlfY29uZl9yZXNldChzdHJ1Y3QgaGRtaV9jb250ZXh0ICpoZGF0YSkKIHsKLQl1OCBidWZmZXJbMl07CiAJdTMyIHJlZzsKIAogCWNsa19kaXNhYmxlX3VucHJlcGFyZShoZGF0YS0+cmVzLnNjbGtfaGRtaSk7CkBAIC0xNjc3LDExICsxNjc2LDggQEAKIAljbGtfcHJlcGFyZV9lbmFibGUoaGRhdGEtPnJlcy5zY2xrX2hkbWkpOwogCiAJLyogb3BlcmF0aW9uIG1vZGUgKi8KLQlidWZmZXJbMF0gPSAweDFmOwotCWJ1ZmZlclsxXSA9IDB4MDA7Ci0KLQlpZiAoaGRhdGEtPmhkbWlwaHlfcG9ydCkKLQkJaTJjX21hc3Rlcl9zZW5kKGhkYXRhLT5oZG1pcGh5X3BvcnQsIGJ1ZmZlciwgMik7CisJaGRtaXBoeV9yZWdfd3JpdGViKGhkYXRhLCBIRE1JUEhZX01PREVfU0VUX0RPTkUsCisJCQkJSERNSV9QSFlfRU5BQkxFX01PREVfU0VUKTsKIAogCWlmIChoZGF0YS0+dHlwZSA9PSBIRE1JX1RZUEUxMykKIAkJcmVnID0gSERNSV9WMTNfUEhZX1JTVE9VVDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9leHlub3MvZXh5bm9zX21peGVyLmMgYi9kcml2ZXJzL2dwdS9kcm0vZXh5bm9zL2V4eW5vc19taXhlci5jCmluZGV4IDgyMGI3NjIuLjA2NGVkNjUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9leHlub3MvZXh5bm9zX21peGVyLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2V4eW5vcy9leHlub3NfbWl4ZXIuYwpAQCAtMTAyNiw2ICsxMDI2LDcgQEAKIHN0YXRpYyB2b2lkIG1peGVyX3dhaXRfZm9yX3ZibGFuayhzdHJ1Y3QgZXh5bm9zX2RybV9tYW5hZ2VyICptZ3IpCiB7CiAJc3RydWN0IG1peGVyX2NvbnRleHQgKm1peGVyX2N0eCA9IG1ncl90b19taXhlcihtZ3IpOworCWludCBlcnI7CiAKIAltdXRleF9sb2NrKCZtaXhlcl9jdHgtPm1peGVyX211dGV4KTsKIAlpZiAoIW1peGVyX2N0eC0+cG93ZXJlZCkgewpAQCAtMTAzNCw3ICsxMDM1LDExIEBACiAJfQogCW11dGV4X3VubG9jaygmbWl4ZXJfY3R4LT5taXhlcl9tdXRleCk7CiAKLQlkcm1fdmJsYW5rX2dldChtZ3ItPmNydGMtPmRldiwgbWl4ZXJfY3R4LT5waXBlKTsKKwllcnIgPSBkcm1fdmJsYW5rX2dldChtZ3ItPmNydGMtPmRldiwgbWl4ZXJfY3R4LT5waXBlKTsKKwlpZiAoZXJyIDwgMCkgeworCQlEUk1fREVCVUdfS01TKCJmYWlsZWQgdG8gYWNxdWlyZSB2YmxhbmsgY291bnRlclxuIik7CisJCXJldHVybjsKKwl9CiAKIAlhdG9taWNfc2V0KCZtaXhlcl9jdHgtPndhaXRfdnN5bmNfZXZlbnQsIDEpOwogCkBAIC0xMjYyLDggKzEyNjcsNiBAQAogCQlyZXR1cm4gcmV0OwogCX0KIAotCXBtX3J1bnRpbWVfZW5hYmxlKGRldik7Ci0KIAlyZXR1cm4gMDsKIH0KIApAQCAtMTI3Miw4ICsxMjc1LDYgQEAKIAlzdHJ1Y3QgbWl4ZXJfY29udGV4dCAqY3R4ID0gZGV2X2dldF9kcnZkYXRhKGRldik7CiAKIAltaXhlcl9tZ3JfcmVtb3ZlKCZjdHgtPm1hbmFnZXIpOwotCi0JcG1fcnVudGltZV9kaXNhYmxlKGRldik7CiB9CiAKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgY29tcG9uZW50X29wcyBtaXhlcl9jb21wb25lbnRfb3BzID0gewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2kyYy90ZGE5OTh4X2Rydi5jIGIvZHJpdmVycy9ncHUvZHJtL2kyYy90ZGE5OTh4X2Rydi5jCmluZGV4IGQ0NzYyNzkuLmE5MDQxZDEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pMmMvdGRhOTk4eF9kcnYuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTJjL3RkYTk5OHhfZHJ2LmMKQEAgLTMyLDYgKzMyLDggQEAKIHN0cnVjdCB0ZGE5OTh4X3ByaXYgewogCXN0cnVjdCBpMmNfY2xpZW50ICpjZWM7CiAJc3RydWN0IGkyY19jbGllbnQgKmhkbWk7CisJc3RydWN0IG11dGV4IG11dGV4OworCXN0cnVjdCBkZWxheWVkX3dvcmsgZHdvcms7CiAJdWludDE2X3QgcmV2OwogCXVpbnQ4X3QgY3VycmVudF9wYWdlOwogCWludCBkcG1zOwpAQCAtNDAyLDkgKzQwNCwxMCBAQAogCXVpbnQ4X3QgYWRkciA9IFJFRzJBRERSKHJlZyk7CiAJaW50IHJldDsKIAorCW11dGV4X2xvY2soJnByaXYtPm11dGV4KTsKIAlyZXQgPSBzZXRfcGFnZShwcml2LCByZWcpOwogCWlmIChyZXQgPCAwKQotCQlyZXR1cm4gcmV0OworCQlnb3RvIG91dDsKIAogCXJldCA9IGkyY19tYXN0ZXJfc2VuZChjbGllbnQsICZhZGRyLCBzaXplb2YoYWRkcikpOwogCWlmIChyZXQgPCAwKQpAQCAtNDE0LDEwICs0MTcsMTIgQEAKIAlpZiAocmV0IDwgMCkKIAkJZ290byBmYWlsOwogCi0JcmV0dXJuIHJldDsKKwlnb3RvIG91dDsKIAogZmFpbDoKIAlkZXZfZXJyKCZjbGllbnQtPmRldiwgIkVycm9yICVkIHJlYWRpbmcgZnJvbSAweCV4XG4iLCByZXQsIHJlZyk7CitvdXQ6CisJbXV0ZXhfdW5sb2NrKCZwcml2LT5tdXRleCk7CiAJcmV0dXJuIHJldDsKIH0KIApAQCAtNDMxLDEzICs0MzYsMTYgQEAKIAlidWZbMF0gPSBSRUcyQUREUihyZWcpOwogCW1lbWNweSgmYnVmWzFdLCBwLCBjbnQpOwogCisJbXV0ZXhfbG9jaygmcHJpdi0+bXV0ZXgpOwogCXJldCA9IHNldF9wYWdlKHByaXYsIHJlZyk7CiAJaWYgKHJldCA8IDApCi0JCXJldHVybjsKKwkJZ290byBvdXQ7CiAKIAlyZXQgPSBpMmNfbWFzdGVyX3NlbmQoY2xpZW50LCBidWYsIGNudCArIDEpOwogCWlmIChyZXQgPCAwKQogCQlkZXZfZXJyKCZjbGllbnQtPmRldiwgIkVycm9yICVkIHdyaXRpbmcgdG8gMHgleFxuIiwgcmV0LCByZWcpOworb3V0OgorCW11dGV4X3VubG9jaygmcHJpdi0+bXV0ZXgpOwogfQogCiBzdGF0aWMgaW50CkBAIC00NTksMTMgKzQ2NywxNiBAQAogCXVpbnQ4X3QgYnVmW10gPSB7UkVHMkFERFIocmVnKSwgdmFsfTsKIAlpbnQgcmV0OwogCisJbXV0ZXhfbG9jaygmcHJpdi0+bXV0ZXgpOwogCXJldCA9IHNldF9wYWdlKHByaXYsIHJlZyk7CiAJaWYgKHJldCA8IDApCi0JCXJldHVybjsKKwkJZ290byBvdXQ7CiAKIAlyZXQgPSBpMmNfbWFzdGVyX3NlbmQoY2xpZW50LCBidWYsIHNpemVvZihidWYpKTsKIAlpZiAocmV0IDwgMCkKIAkJZGV2X2VycigmY2xpZW50LT5kZXYsICJFcnJvciAlZCB3cml0aW5nIHRvIDB4JXhcbiIsIHJldCwgcmVnKTsKK291dDoKKwltdXRleF91bmxvY2soJnByaXYtPm11dGV4KTsKIH0KIAogc3RhdGljIHZvaWQKQEAgLTQ3NSwxMyArNDg2LDE2IEBACiAJdWludDhfdCBidWZbXSA9IHtSRUcyQUREUihyZWcpLCB2YWwgPj4gOCwgdmFsfTsKIAlpbnQgcmV0OwogCisJbXV0ZXhfbG9jaygmcHJpdi0+bXV0ZXgpOwogCXJldCA9IHNldF9wYWdlKHByaXYsIHJlZyk7CiAJaWYgKHJldCA8IDApCi0JCXJldHVybjsKKwkJZ290byBvdXQ7CiAKIAlyZXQgPSBpMmNfbWFzdGVyX3NlbmQoY2xpZW50LCBidWYsIHNpemVvZihidWYpKTsKIAlpZiAocmV0IDwgMCkKIAkJZGV2X2VycigmY2xpZW50LT5kZXYsICJFcnJvciAlZCB3cml0aW5nIHRvIDB4JXhcbiIsIHJldCwgcmVnKTsKK291dDoKKwltdXRleF91bmxvY2soJnByaXYtPm11dGV4KTsKIH0KIAogc3RhdGljIHZvaWQKQEAgLTUzNiw2ICs1NTAsMTcgQEAKIAlyZWdfd3JpdGUocHJpdiwgUkVHX01VWF9WUF9WSVBfT1VULCAweDI0KTsKIH0KIAorLyogaGFuZGxlIEhETUkgY29ubmVjdC9kaXNjb25uZWN0ICovCitzdGF0aWMgdm9pZCB0ZGE5OTh4X2hwZChzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCit7CisJc3RydWN0IGRlbGF5ZWRfd29yayAqZHdvcmsgPSB0b19kZWxheWVkX3dvcmsod29yayk7CisJc3RydWN0IHRkYTk5OHhfcHJpdiAqcHJpdiA9CisJCQljb250YWluZXJfb2YoZHdvcmssIHN0cnVjdCB0ZGE5OTh4X3ByaXYsIGR3b3JrKTsKKworCWlmIChwcml2LT5lbmNvZGVyICYmIHByaXYtPmVuY29kZXItPmRldikKKwkJZHJtX2ttc19oZWxwZXJfaG90cGx1Z19ldmVudChwcml2LT5lbmNvZGVyLT5kZXYpOworfQorCiAvKgogICogb25seSAyIGludGVycnVwdHMgbWF5IG9jY3VyOiBzY3JlZW4gcGx1Zy91bnBsdWcgYW5kIEVESUQgcmVhZAogICovCkBAIC01NTksOCArNTg0LDcgQEAKIAkJcHJpdi0+d3FfZWRpZF93YWl0ID0gMDsKIAkJd2FrZV91cCgmcHJpdi0+d3FfZWRpZCk7CiAJfSBlbHNlIGlmIChjZWMgIT0gMCkgewkJCS8qIEhQRCBjaGFuZ2UgKi8KLQkJaWYgKHByaXYtPmVuY29kZXIgJiYgcHJpdi0+ZW5jb2Rlci0+ZGV2KQotCQkJZHJtX2hlbHBlcl9ocGRfaXJxX2V2ZW50KHByaXYtPmVuY29kZXItPmRldik7CisJCXNjaGVkdWxlX2RlbGF5ZWRfd29yaygmcHJpdi0+ZHdvcmssIEhaLzEwKTsKIAl9CiAJcmV0dXJuIElSUV9IQU5ETEVEOwogfQpAQCAtMTE3MCw4ICsxMTk0LDEwIEBACiAJLyogZGlzYWJsZSBhbGwgSVJRcyBhbmQgZnJlZSB0aGUgSVJRIGhhbmRsZXIgKi8KIAljZWNfd3JpdGUocHJpdiwgUkVHX0NFQ19SWFNIUERJTlRFTkEsIDApOwogCXJlZ19jbGVhcihwcml2LCBSRUdfSU5UX0ZMQUdTXzIsIElOVF9GTEFHU18yX0VESURfQkxLX1JEKTsKLQlpZiAocHJpdi0+aGRtaS0+aXJxKQorCWlmIChwcml2LT5oZG1pLT5pcnEpIHsKIAkJZnJlZV9pcnEocHJpdi0+aGRtaS0+aXJxLCBwcml2KTsKKwkJY2FuY2VsX2RlbGF5ZWRfd29ya19zeW5jKCZwcml2LT5kd29yayk7CisJfQogCiAJaTJjX3VucmVnaXN0ZXJfZGV2aWNlKHByaXYtPmNlYyk7CiB9CkBAIC0xMjU1LDYgKzEyODEsNyBAQAogCXN0cnVjdCBkZXZpY2Vfbm9kZSAqbnAgPSBjbGllbnQtPmRldi5vZl9ub2RlOwogCXUzMiB2aWRlbzsKIAlpbnQgcmV2X2xvLCByZXZfaGksIHJldDsKKwl1bnNpZ25lZCBzaG9ydCBjZWNfYWRkcjsKIAogCXByaXYtPnZpcF9jbnRybF8wID0gVklQX0NOVFJMXzBfU1dBUF9BKDIpIHwgVklQX0NOVFJMXzBfU1dBUF9CKDMpOwogCXByaXYtPnZpcF9jbnRybF8xID0gVklQX0NOVFJMXzFfU1dBUF9DKDApIHwgVklQX0NOVFJMXzFfU1dBUF9EKDEpOwpAQCAtMTI2MiwxMiArMTI4OSwxNiBAQAogCiAJcHJpdi0+Y3VycmVudF9wYWdlID0gMHhmZjsKIAlwcml2LT5oZG1pID0gY2xpZW50OwotCXByaXYtPmNlYyA9IGkyY19uZXdfZHVtbXkoY2xpZW50LT5hZGFwdGVyLCAweDM0KTsKKwkvKiBDRUMgSTJDIGFkZHJlc3MgYm91bmQgdG8gVERBOTk4eCBJMkMgYWRkciBieSBjb25maWd1cmF0aW9uIHBpbnMgKi8KKwljZWNfYWRkciA9IDB4MzQgKyAoY2xpZW50LT5hZGRyICYgMHgwMyk7CisJcHJpdi0+Y2VjID0gaTJjX25ld19kdW1teShjbGllbnQtPmFkYXB0ZXIsIGNlY19hZGRyKTsKIAlpZiAoIXByaXYtPmNlYykKIAkJcmV0dXJuIC1FTk9ERVY7CiAKIAlwcml2LT5kcG1zID0gRFJNX01PREVfRFBNU19PRkY7CiAKKwltdXRleF9pbml0KCZwcml2LT5tdXRleCk7CS8qIHByb3RlY3QgdGhlIHBhZ2UgYWNjZXNzICovCisKIAkvKiB3YWtlIHVwIHRoZSBkZXZpY2U6ICovCiAJY2VjX3dyaXRlKHByaXYsIFJFR19DRUNfRU5BTU9EUywKIAkJCUNFQ19FTkFNT0RTX0VOX1JYU0VOUyB8IENFQ19FTkFNT0RTX0VOX0hETUkpOwpAQCAtMTMyMyw4ICsxMzU0LDkgQEAKIAlpZiAoY2xpZW50LT5pcnEpIHsKIAkJaW50IGlycWZfdHJpZ2dlcjsKIAotCQkvKiBpbml0IHJlYWQgRURJRCB3YWl0cXVldWUgKi8KKwkJLyogaW5pdCByZWFkIEVESUQgd2FpdHF1ZXVlIGFuZCBIRFAgd29yayAqLwogCQlpbml0X3dhaXRxdWV1ZV9oZWFkKCZwcml2LT53cV9lZGlkKTsKKwkJSU5JVF9ERUxBWUVEX1dPUksoJnByaXYtPmR3b3JrLCB0ZGE5OTh4X2hwZCk7CiAKIAkJLyogY2xlYXIgcGVuZGluZyBpbnRlcnJ1cHRzICovCiAJCXJlZ19yZWFkKHByaXYsIFJFR19JTlRfRkxBR1NfMCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuYwppbmRleCA1NzQwNTdjLi43NjQzMzAwIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmMKQEAgLTQ2MiwxOSArNDYyLDEzIEBACiAJCQl9IGVsc2UgaWYgKGlkID09IElOVEVMX1BDSF9MUFRfREVWSUNFX0lEX1RZUEUpIHsKIAkJCQlkZXZfcHJpdi0+cGNoX3R5cGUgPSBQQ0hfTFBUOwogCQkJCURSTV9ERUJVR19LTVMoIkZvdW5kIEx5bnhQb2ludCBQQ0hcbiIpOwotCQkJCVdBUk5fT04oIUlTX0hBU1dFTEwoZGV2KSk7Ci0JCQkJV0FSTl9PTihJU19IU1dfVUxUKGRldikpOwotCQkJfSBlbHNlIGlmIChJU19CUk9BRFdFTEwoZGV2KSkgewotCQkJCWRldl9wcml2LT5wY2hfdHlwZSA9IFBDSF9MUFQ7Ci0JCQkJZGV2X3ByaXYtPnBjaF9pZCA9Ci0JCQkJCUlOVEVMX1BDSF9MUFRfTFBfREVWSUNFX0lEX1RZUEU7Ci0JCQkJRFJNX0RFQlVHX0tNUygiVGhpcyBpcyBCcm9hZHdlbGwsIGFzc3VtaW5nICIKLQkJCQkJICAgICAgIkx5bnhQb2ludCBMUCBQQ0hcbiIpOworCQkJCVdBUk5fT04oIUlTX0hBU1dFTEwoZGV2KSAmJiAhSVNfQlJPQURXRUxMKGRldikpOworCQkJCVdBUk5fT04oSVNfSFNXX1VMVChkZXYpIHx8IElTX0JEV19VTFQoZGV2KSk7CiAJCQl9IGVsc2UgaWYgKGlkID09IElOVEVMX1BDSF9MUFRfTFBfREVWSUNFX0lEX1RZUEUpIHsKIAkJCQlkZXZfcHJpdi0+cGNoX3R5cGUgPSBQQ0hfTFBUOwogCQkJCURSTV9ERUJVR19LTVMoIkZvdW5kIEx5bnhQb2ludCBMUCBQQ0hcbiIpOwotCQkJCVdBUk5fT04oIUlTX0hBU1dFTEwoZGV2KSk7Ci0JCQkJV0FSTl9PTighSVNfSFNXX1VMVChkZXYpKTsKKwkJCQlXQVJOX09OKCFJU19IQVNXRUxMKGRldikgJiYgIUlTX0JST0FEV0VMTChkZXYpKTsKKwkJCQlXQVJOX09OKCFJU19IU1dfVUxUKGRldikgJiYgIUlTX0JEV19VTFQoZGV2KSk7CiAJCQl9IGVsc2UgaWYgKGlkID09IElOVEVMX1BDSF9TUFRfREVWSUNFX0lEX1RZUEUpIHsKIAkJCQlkZXZfcHJpdi0+cGNoX3R5cGUgPSBQQ0hfU1BUOwogCQkJCURSTV9ERUJVR19LTVMoIkZvdW5kIFN1bnJpc2VQb2ludCBQQ0hcbiIpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmgKaW5kZXggZTlmODkxYy4uOWQ3YTcxNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5oCkBAIC0yMTU5LDggKzIxNTksNyBAQAogI2RlZmluZSBJU19IU1dfRUFSTFlfU0RWKGRldikJKElTX0hBU1dFTEwoZGV2KSAmJiBcCiAJCQkJIChJTlRFTF9ERVZJRChkZXYpICYgMHhGRjAwKSA9PSAweDBDMDApCiAjZGVmaW5lIElTX0JEV19VTFQoZGV2KQkJKElTX0JST0FEV0VMTChkZXYpICYmIFwKLQkJCQkgKChJTlRFTF9ERVZJRChkZXYpICYgMHhmKSA9PSAweDIgIHx8IFwKLQkJCQkgKElOVEVMX0RFVklEKGRldikgJiAweGYpID09IDB4NiB8fCBcCisJCQkJICgoSU5URUxfREVWSUQoZGV2KSAmIDB4ZikgPT0gMHg2IHx8CVwKIAkJCQkgKElOVEVMX0RFVklEKGRldikgJiAweGYpID09IDB4ZSkpCiAjZGVmaW5lIElTX0JEV19HVDMoZGV2KQkJKElTX0JST0FEV0VMTChkZXYpICYmIFwKIAkJCQkgKElOVEVMX0RFVklEKGRldikgJiAweDAwRjApID09IDB4MDAyMCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dlbS5jCmluZGV4IGMxMTYwM2IuLjVmNjE0ODIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW0uYwpAQCAtMzE0OCw2ICszMTQ4LDEzIEBACiAJCXUzMiBzaXplID0gaTkxNV9nZW1fb2JqX2dndHRfc2l6ZShvYmopOwogCQl1aW50NjRfdCB2YWw7CiAKKwkJLyogQWRqdXN0IGZlbmNlIHNpemUgdG8gbWF0Y2ggdGlsZWQgYXJlYSAqLworCQlpZiAob2JqLT50aWxpbmdfbW9kZSAhPSBJOTE1X1RJTElOR19OT05FKSB7CisJCQl1aW50MzJfdCByb3dfc2l6ZSA9IG9iai0+c3RyaWRlICoKKwkJCQkob2JqLT50aWxpbmdfbW9kZSA9PSBJOTE1X1RJTElOR19ZID8gMzIgOiA4KTsKKwkJCXNpemUgPSAoc2l6ZSAvIHJvd19zaXplKSAqIHJvd19zaXplOworCQl9CisKIAkJdmFsID0gKHVpbnQ2NF90KSgoaTkxNV9nZW1fb2JqX2dndHRfb2Zmc2V0KG9iaikgKyBzaXplIC0gNDA5NikgJgogCQkJCSAweGZmZmZmMDAwKSA8PCAzMjsKIAkJdmFsIHw9IGk5MTVfZ2VtX29ial9nZ3R0X29mZnNldChvYmopICYgMHhmZmZmZjAwMDsKQEAgLTQ4ODQsMTMgKzQ4OTEsMTIgQEAKIAlmb3IgKGkgPSAwOyBpIDwgTlVNX0wzX1NMSUNFUyhkZXYpOyBpKyspCiAJCWk5MTVfZ2VtX2wzX3JlbWFwKCZkZXZfcHJpdi0+cmluZ1tSQ1NdLCBpKTsKIAotCS8qCi0JICogWFhYOiBDb250ZXh0cyBzaG91bGQgb25seSBiZSBpbml0aWFsaXplZCBvbmNlLiBEb2luZyBhIHN3aXRjaCB0byB0aGUKLQkgKiBkZWZhdWx0IGNvbnRleHQgc3dpdGNoIGhvd2V2ZXIgaXMgc29tZXRoaW5nIHdlJ2QgbGlrZSB0byBkbyBhZnRlcgotCSAqIHJlc2V0IG9yIHRoYXcgKHRoZSBsYXR0ZXIgbWF5IG5vdCBhY3R1YWxseSBiZSBuZWNlc3NhcnkgZm9yIEhXLCBidXQKLQkgKiBnb2VzIHdpdGggb3VyIGNvZGUgYmV0dGVyKS4gQ29udGV4dCBzd2l0Y2hpbmcgcmVxdWlyZXMgcmluZ3MgKGZvcgotCSAqIHRoZSBkb19zd2l0Y2gpLCBidXQgYmVmb3JlIGVuYWJsaW5nIFBQR1RULiBTbyBkb24ndCBtb3ZlIHRoaXMuCi0JICovCisJcmV0ID0gaTkxNV9wcGd0dF9pbml0X2h3KGRldik7CisJaWYgKHJldCAmJiByZXQgIT0gLUVJTykgeworCQlEUk1fRVJST1IoIlBQR1RUIGVuYWJsZSBmYWlsZWQgJWRcbiIsIHJldCk7CisJCWk5MTVfZ2VtX2NsZWFudXBfcmluZ2J1ZmZlcihkZXYpOworCX0KKwogCXJldCA9IGk5MTVfZ2VtX2NvbnRleHRfZW5hYmxlKGRldl9wcml2KTsKIAlpZiAocmV0ICYmIHJldCAhPSAtRUlPKSB7CiAJCURSTV9FUlJPUigiQ29udGV4dCBlbmFibGUgZmFpbGVkICVkXG4iLCByZXQpOwpAQCAtNDg5OSwxMiArNDkwNSw2IEBACiAJCXJldHVybiByZXQ7CiAJfQogCi0JcmV0ID0gaTkxNV9wcGd0dF9pbml0X2h3KGRldik7Ci0JaWYgKHJldCAmJiByZXQgIT0gLUVJTykgewotCQlEUk1fRVJST1IoIlBQR1RUIGVuYWJsZSBmYWlsZWQgJWRcbiIsIHJldCk7Ci0JCWk5MTVfZ2VtX2NsZWFudXBfcmluZ2J1ZmZlcihkZXYpOwotCX0KLQogCXJldHVybiByZXQ7CiB9CiAKQEAgLTUxNTUsNyArNTE1NSw3IEBACiAJaWYgKCFtdXRleF9pc19sb2NrZWQobXV0ZXgpKQogCQlyZXR1cm4gZmFsc2U7CiAKLSNpZiBkZWZpbmVkKENPTkZJR19TTVApIHx8IGRlZmluZWQoQ09ORklHX0RFQlVHX01VVEVYRVMpCisjaWYgZGVmaW5lZChDT05GSUdfU01QKSAmJiAhZGVmaW5lZChDT05GSUdfREVCVUdfTVVURVhFUykKIAlyZXR1cm4gbXV0ZXgtPm93bmVyID09IHRhc2s7CiAjZWxzZQogCS8qIFNpbmNlIFVQIG1heSBiZSBwcmUtZW1wdGVkLCB3ZSBjYW5ub3QgYXNzdW1lIHRoYXQgd2Ugb3duIHRoZSBsb2NrICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2lycS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9pcnEuYwppbmRleCBkMGQzZGZiLi5iMDUxYTIzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2lycS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfaXJxLmMKQEAgLTI5Miw2ICsyOTIsMjMgQEAKIAlzcGluX3VubG9ja19pcnEoJmRldl9wcml2LT5pcnFfbG9jayk7CiB9CiAKK3UzMiBnZW42X3Nhbml0aXplX3Jwc19wbV9tYXNrKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiwgdTMyIG1hc2spCit7CisJLyoKKwkgKiBTTkIsSVZCIGNhbiB3aGlsZSBWTFYsQ0hWIG1heSBoYXJkIGhhbmcgb24gbG9vcGluZyBiYXRjaGJ1ZmZlcgorCSAqIGlmIEdFTjZfUE1fVVBfRUlfRVhQSVJFRCBpcyBtYXNrZWQuCisJICoKKwkgKiBUT0RPOiB2ZXJpZnkgaWYgdGhpcyBjYW4gYmUgcmVwcm9kdWNlZCBvbiBWTFYsQ0hWLgorCSAqLworCWlmIChJTlRFTF9JTkZPKGRldl9wcml2KS0+Z2VuIDw9IDcgJiYgIUlTX0hBU1dFTEwoZGV2X3ByaXYpKQorCQltYXNrICY9IH5HRU42X1BNX1JQX1VQX0VJX0VYUElSRUQ7CisKKwlpZiAoSU5URUxfSU5GTyhkZXZfcHJpdiktPmdlbiA+PSA4KQorCQltYXNrICY9IH5HRU44X1BNSU5UUl9SRURJUkVDVF9UT19OT05fRElTUDsKKworCXJldHVybiBtYXNrOworfQorCiB2b2lkIGdlbjZfZGlzYWJsZV9ycHNfaW50ZXJydXB0cyhzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQogewogCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IGRldi0+ZGV2X3ByaXZhdGU7CkBAIC0zMDQsOCArMzIxLDcgQEAKIAogCXNwaW5fbG9ja19pcnEoJmRldl9wcml2LT5pcnFfbG9jayk7CiAKLQlJOTE1X1dSSVRFKEdFTjZfUE1JTlRSTVNLLCBJTlRFTF9JTkZPKGRldl9wcml2KS0+Z2VuID49IDggPwotCQkgICB+R0VOOF9QTUlOVFJfUkVESVJFQ1RfVE9fTk9OX0RJU1AgOiB+MCk7CisJSTkxNV9XUklURShHRU42X1BNSU5UUk1TSywgZ2VuNl9zYW5pdGl6ZV9ycHNfcG1fbWFzayhkZXZfcHJpdiwgfjApKTsKIAogCV9fZ2VuNl9kaXNhYmxlX3BtX2lycShkZXZfcHJpdiwgZGV2X3ByaXYtPnBtX3Jwc19ldmVudHMpOwogCUk5MTVfV1JJVEUoZ2VuNl9wbV9pZXIoZGV2X3ByaXYpLCBJOTE1X1JFQUQoZ2VuNl9wbV9pZXIoZGV2X3ByaXYpKSAmCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMKaW5kZXggZTJhZjEzOC4uZTdhMTZmMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXkuYwpAQCAtOTgxNSw3ICs5ODE1LDcgQEAKIAkJaWYgKG9iai0+dGlsaW5nX21vZGUgIT0gd29yay0+b2xkX2ZiX29iai0+dGlsaW5nX21vZGUpCiAJCQkvKiB2bHY6IERJU1BMQVlfRkxJUCBmYWlscyB0byBjaGFuZ2UgdGlsaW5nICovCiAJCQlyaW5nID0gTlVMTDsKLQl9IGVsc2UgaWYgKElTX0lWWUJSSURHRShkZXYpKSB7CisJfSBlbHNlIGlmIChJU19JVllCUklER0UoZGV2KSB8fCBJU19IQVNXRUxMKGRldikpIHsKIAkJcmluZyA9ICZkZXZfcHJpdi0+cmluZ1tCQ1NdOwogCX0gZWxzZSBpZiAoSU5URUxfSU5GTyhkZXYpLT5nZW4gPj0gNykgewogCQlyaW5nID0gb2JqLT5yaW5nOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2LmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaAppbmRleCAyNWZkYmIxLi4zYjQwYTE3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaApAQCAtNzk0LDYgKzc5NCw3IEBACiB2b2lkIGdlbjZfcmVzZXRfcnBzX2ludGVycnVwdHMoc3RydWN0IGRybV9kZXZpY2UgKmRldik7CiB2b2lkIGdlbjZfZW5hYmxlX3Jwc19pbnRlcnJ1cHRzKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpOwogdm9pZCBnZW42X2Rpc2FibGVfcnBzX2ludGVycnVwdHMoc3RydWN0IGRybV9kZXZpY2UgKmRldik7Cit1MzIgZ2VuNl9zYW5pdGl6ZV9ycHNfcG1fbWFzayhzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYsIHUzMiBtYXNrKTsKIHZvaWQgaW50ZWxfcnVudGltZV9wbV9kaXNhYmxlX2ludGVycnVwdHMoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2KTsKIHZvaWQgaW50ZWxfcnVudGltZV9wbV9lbmFibGVfaW50ZXJydXB0cyhzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYpOwogc3RhdGljIGlubGluZSBib29sIGludGVsX2lycXNfZW5hYmxlZChzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYpCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9wYW5lbC5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcGFuZWwuYwppbmRleCA0ZDYzODM5Li5kZmI3ODNhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9wYW5lbC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3BhbmVsLmMKQEAgLTk2Miw3ICs5NjIsNyBAQAogCiAJV0FSTl9PTihwYW5lbC0+YmFja2xpZ2h0Lm1heCA9PSAwKTsKIAotCWlmIChwYW5lbC0+YmFja2xpZ2h0LmxldmVsID09IDApIHsKKwlpZiAocGFuZWwtPmJhY2tsaWdodC5sZXZlbCA8PSBwYW5lbC0+YmFja2xpZ2h0Lm1pbikgewogCQlwYW5lbC0+YmFja2xpZ2h0LmxldmVsID0gcGFuZWwtPmJhY2tsaWdodC5tYXg7CiAJCWlmIChwYW5lbC0+YmFja2xpZ2h0LmRldmljZSkKIAkJCXBhbmVsLT5iYWNrbGlnaHQuZGV2aWNlLT5wcm9wcy5icmlnaHRuZXNzID0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3BtLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9wbS5jCmluZGV4IDk2NGIyOGUuLmJmODE0YTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3BtLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcG0uYwpAQCAtNDM2MywxNiArNDM2Myw3IEBACiAJbWFzayB8PSBkZXZfcHJpdi0+cG1fcnBzX2V2ZW50cyAmIChHRU42X1BNX1JQX0RPV05fRUlfRVhQSVJFRCB8IEdFTjZfUE1fUlBfVVBfRUlfRVhQSVJFRCk7CiAJbWFzayAmPSBkZXZfcHJpdi0+cG1fcnBzX2V2ZW50czsKIAotCS8qIElWQiBhbmQgU05CIGhhcmQgaGFuZ3Mgb24gbG9vcGluZyBiYXRjaGJ1ZmZlcgotCSAqIGlmIEdFTjZfUE1fVVBfRUlfRVhQSVJFRCBpcyBtYXNrZWQuCi0JICovCi0JaWYgKElOVEVMX0lORk8oZGV2X3ByaXYtPmRldiktPmdlbiA8PSA3ICYmICFJU19IQVNXRUxMKGRldl9wcml2LT5kZXYpKQotCQltYXNrIHw9IEdFTjZfUE1fUlBfVVBfRUlfRVhQSVJFRDsKLQotCWlmIChJU19HRU44KGRldl9wcml2LT5kZXYpKQotCQltYXNrIHw9IEdFTjhfUE1JTlRSX1JFRElSRUNUX1RPX05PTl9ESVNQOwotCi0JcmV0dXJuIH5tYXNrOworCXJldHVybiBnZW42X3Nhbml0aXplX3Jwc19wbV9tYXNrKGRldl9wcml2LCB+bWFzayk7CiB9CiAKIC8qIGdlbjZfc2V0X3JwcyBpcyBjYWxsZWQgdG8gdXBkYXRlIHRoZSBmcmVxdWVuY3kgcmVxdWVzdCwgYnV0IHNob3VsZCBhbHNvIGJlCkBAIC00NDQxLDcgKzQ0MzIsOCBAQAogCQlyZXR1cm47CiAKIAkvKiBNYXNrIHR1cmJvIGludGVycnVwdCBzbyB0aGF0IHRoZXkgd2lsbCBub3QgY29tZSBpbiBiZXR3ZWVuICovCi0JSTkxNV9XUklURShHRU42X1BNSU5UUk1TSywgMHhmZmZmZmZmZik7CisJSTkxNV9XUklURShHRU42X1BNSU5UUk1TSywKKwkJICAgZ2VuNl9zYW5pdGl6ZV9ycHNfcG1fbWFzayhkZXZfcHJpdiwgfjApKTsKIAogCXZsdl9mb3JjZV9nZnhfY2xvY2soZGV2X3ByaXYsIHRydWUpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL2Npay5jIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9jaWsuYwppbmRleCA2ZGNkZTM3Li42NGZkYWU1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL2Npay5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vY2lrLmMKQEAgLTYwMzMsNiArNjAzMywxNyBAQAogCXJhZGVvbl9yaW5nX3dyaXRlKHJpbmcsIDApOwogCXJhZGVvbl9yaW5nX3dyaXRlKHJpbmcsIDEgPDwgdm1faWQpOwogCisJLyogd2FpdCBmb3IgdGhlIGludmFsaWRhdGUgdG8gY29tcGxldGUgKi8KKwlyYWRlb25fcmluZ193cml0ZShyaW5nLCBQQUNLRVQzKFBBQ0tFVDNfV0FJVF9SRUdfTUVNLCA1KSk7CisJcmFkZW9uX3Jpbmdfd3JpdGUocmluZywgKFdBSVRfUkVHX01FTV9PUEVSQVRJT04oMCkgfCAvKiB3YWl0ICovCisJCQkJIFdBSVRfUkVHX01FTV9GVU5DVElPTigwKSB8ICAvKiBhbHdheXMgKi8KKwkJCQkgV0FJVF9SRUdfTUVNX0VOR0lORSgwKSkpOyAvKiBtZSAqLworCXJhZGVvbl9yaW5nX3dyaXRlKHJpbmcsIFZNX0lOVkFMSURBVEVfUkVRVUVTVCA+PiAyKTsKKwlyYWRlb25fcmluZ193cml0ZShyaW5nLCAwKTsKKwlyYWRlb25fcmluZ193cml0ZShyaW5nLCAwKTsgLyogcmVmICovCisJcmFkZW9uX3Jpbmdfd3JpdGUocmluZywgMCk7IC8qIG1hc2sgKi8KKwlyYWRlb25fcmluZ193cml0ZShyaW5nLCAweDIwKTsgLyogcG9sbCBpbnRlcnZhbCAqLworCiAJLyogY29tcHV0ZSBkb2Vzbid0IGhhdmUgUEZQICovCiAJaWYgKHVzZXBmcCkgewogCQkvKiBzeW5jIFBGUCB0byBNRSwgb3RoZXJ3aXNlIHdlIG1pZ2h0IGdldCBpbnZhbGlkIFBGUCByZWFkcyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9jaWtfc2RtYS5jIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9jaWtfc2RtYS5jCmluZGV4IGRkZTVjN2UuLjQyY2QwY2YgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vY2lrX3NkbWEuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL2Npa19zZG1hLmMKQEAgLTgxNiw3ICs4MTYsNiBAQAogCQlmb3IgKDsgbmR3ID4gMDsgbmR3IC09IDIsIC0tY291bnQsIHBlICs9IDgpIHsKIAkJCWlmIChmbGFncyAmIFI2MDBfUFRFX1NZU1RFTSkgewogCQkJCXZhbHVlID0gcmFkZW9uX3ZtX21hcF9nYXJ0KHJkZXYsIGFkZHIpOwotCQkJCXZhbHVlICY9IDB4RkZGRkZGRkZGRkZGRjAwMFVMTDsKIAkJCX0gZWxzZSBpZiAoZmxhZ3MgJiBSNjAwX1BURV9WQUxJRCkgewogCQkJCXZhbHVlID0gYWRkcjsKIAkJCX0gZWxzZSB7CkBAIC05MDMsNiArOTAyLDkgQEAKIHZvaWQgY2lrX2RtYV92bV9mbHVzaChzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldiwgc3RydWN0IHJhZGVvbl9yaW5nICpyaW5nLAogCQkgICAgICB1bnNpZ25lZCB2bV9pZCwgdWludDY0X3QgcGRfYWRkcikKIHsKKwl1MzIgZXh0cmFfYml0cyA9IChTRE1BX1BPTExfUkVHX01FTV9FWFRSQV9PUCgwKSB8CisJCQkgIFNETUFfUE9MTF9SRUdfTUVNX0VYVFJBX0ZVTkMoMCkpOyAvKiBhbHdheXMgKi8KKwogCXJhZGVvbl9yaW5nX3dyaXRlKHJpbmcsIFNETUFfUEFDS0VUKFNETUFfT1BDT0RFX1NSQk1fV1JJVEUsIDAsIDB4ZjAwMCkpOwogCWlmICh2bV9pZCA8IDgpIHsKIAkJcmFkZW9uX3Jpbmdfd3JpdGUocmluZywgKFZNX0NPTlRFWFQwX1BBR0VfVEFCTEVfQkFTRV9BRERSICsgKHZtX2lkIDw8IDIpKSA+PiAyKTsKQEAgLTk0Myw1ICs5NDUsMTIgQEAKIAlyYWRlb25fcmluZ193cml0ZShyaW5nLCBTRE1BX1BBQ0tFVChTRE1BX09QQ09ERV9TUkJNX1dSSVRFLCAwLCAweGYwMDApKTsKIAlyYWRlb25fcmluZ193cml0ZShyaW5nLCBWTV9JTlZBTElEQVRFX1JFUVVFU1QgPj4gMik7CiAJcmFkZW9uX3Jpbmdfd3JpdGUocmluZywgMSA8PCB2bV9pZCk7CisKKwlyYWRlb25fcmluZ193cml0ZShyaW5nLCBTRE1BX1BBQ0tFVChTRE1BX09QQ09ERV9QT0xMX1JFR19NRU0sIDAsIGV4dHJhX2JpdHMpKTsKKwlyYWRlb25fcmluZ193cml0ZShyaW5nLCBWTV9JTlZBTElEQVRFX1JFUVVFU1QgPj4gMik7CisJcmFkZW9uX3Jpbmdfd3JpdGUocmluZywgMCk7CisJcmFkZW9uX3Jpbmdfd3JpdGUocmluZywgMCk7IC8qIHJlZmVyZW5jZSAqLworCXJhZGVvbl9yaW5nX3dyaXRlKHJpbmcsIDApOyAvKiBtYXNrICovCisJcmFkZW9uX3Jpbmdfd3JpdGUocmluZywgKDB4ZmZmIDw8IDE2KSB8IDEwKTsgLyogcmV0cnkgY291bnQsIHBvbGwgaW50ZXJ2YWwgKi8KIH0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9uaS5jIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9uaS5jCmluZGV4IDM2MGRlOWYuLmFlYTQ4YzggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vbmkuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL25pLmMKQEAgLTI1MTYsNiArMjUxNiwxNiBAQAogCXJhZGVvbl9yaW5nX3dyaXRlKHJpbmcsIFBBQ0tFVDAoVk1fSU5WQUxJREFURV9SRVFVRVNULCAwKSk7CiAJcmFkZW9uX3Jpbmdfd3JpdGUocmluZywgMSA8PCB2bV9pZCk7CiAKKwkvKiB3YWl0IGZvciB0aGUgaW52YWxpZGF0ZSB0byBjb21wbGV0ZSAqLworCXJhZGVvbl9yaW5nX3dyaXRlKHJpbmcsIFBBQ0tFVDMoUEFDS0VUM19XQUlUX1JFR19NRU0sIDUpKTsKKwlyYWRlb25fcmluZ193cml0ZShyaW5nLCAoV0FJVF9SRUdfTUVNX0ZVTkNUSU9OKDApIHwgIC8qIGFsd2F5cyAqLworCQkJCSBXQUlUX1JFR19NRU1fRU5HSU5FKDApKSk7IC8qIG1lICovCisJcmFkZW9uX3Jpbmdfd3JpdGUocmluZywgVk1fSU5WQUxJREFURV9SRVFVRVNUID4+IDIpOworCXJhZGVvbl9yaW5nX3dyaXRlKHJpbmcsIDApOworCXJhZGVvbl9yaW5nX3dyaXRlKHJpbmcsIDApOyAvKiByZWYgKi8KKwlyYWRlb25fcmluZ193cml0ZShyaW5nLCAwKTsgLyogbWFzayAqLworCXJhZGVvbl9yaW5nX3dyaXRlKHJpbmcsIDB4MjApOyAvKiBwb2xsIGludGVydmFsICovCisKIAkvKiBzeW5jIFBGUCB0byBNRSwgb3RoZXJ3aXNlIHdlIG1pZ2h0IGdldCBpbnZhbGlkIFBGUCByZWFkcyAqLwogCXJhZGVvbl9yaW5nX3dyaXRlKHJpbmcsIFBBQ0tFVDMoUEFDS0VUM19QRlBfU1lOQ19NRSwgMCkpOwogCXJhZGVvbl9yaW5nX3dyaXRlKHJpbmcsIDB4MCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL25pX2RtYS5jIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9uaV9kbWEuYwppbmRleCA1MGY4ODYxLi5jZTc4N2E5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL25pX2RtYS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vbmlfZG1hLmMKQEAgLTM3Miw3ICszNzIsNiBAQAogCQlmb3IgKDsgbmR3ID4gMDsgbmR3IC09IDIsIC0tY291bnQsIHBlICs9IDgpIHsKIAkJCWlmIChmbGFncyAmIFI2MDBfUFRFX1NZU1RFTSkgewogCQkJCXZhbHVlID0gcmFkZW9uX3ZtX21hcF9nYXJ0KHJkZXYsIGFkZHIpOwotCQkJCXZhbHVlICY9IDB4RkZGRkZGRkZGRkZGRjAwMFVMTDsKIAkJCX0gZWxzZSBpZiAoZmxhZ3MgJiBSNjAwX1BURV9WQUxJRCkgewogCQkJCXZhbHVlID0gYWRkcjsKIAkJCX0gZWxzZSB7CkBAIC00NjMsNSArNDYyLDExIEBACiAJcmFkZW9uX3Jpbmdfd3JpdGUocmluZywgRE1BX1BBQ0tFVChETUFfUEFDS0VUX1NSQk1fV1JJVEUsIDAsIDAsIDApKTsKIAlyYWRlb25fcmluZ193cml0ZShyaW5nLCAoMHhmIDw8IDE2KSB8IChWTV9JTlZBTElEQVRFX1JFUVVFU1QgPj4gMikpOwogCXJhZGVvbl9yaW5nX3dyaXRlKHJpbmcsIDEgPDwgdm1faWQpOworCisJLyogd2FpdCBmb3IgaW52YWxpZGF0ZSB0byBjb21wbGV0ZSAqLworCXJhZGVvbl9yaW5nX3dyaXRlKHJpbmcsIERNQV9TUkJNX1JFQURfUEFDS0VUKTsKKwlyYWRlb25fcmluZ193cml0ZShyaW5nLCAoMHhmZiA8PCAyMCkgfCAoVk1fSU5WQUxJREFURV9SRVFVRVNUID4+IDIpKTsKKwlyYWRlb25fcmluZ193cml0ZShyaW5nLCAwKTsgLyogbWFzayAqLworCXJhZGVvbl9yaW5nX3dyaXRlKHJpbmcsIDApOyAvKiB2YWx1ZSAqLwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL25pZC5oIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9uaWQuaAppbmRleCAyZTEyZTRkLi5hZDcxMjU0IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL25pZC5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vbmlkLmgKQEAgLTExMzMsNiArMTEzMywyMyBAQAogI2RlZmluZQlQQUNLRVQzX01FTV9TRU1BUEhPUkUJCQkJMHgzOQogI2RlZmluZQlQQUNLRVQzX01QRUdfSU5ERVgJCQkJMHgzQQogI2RlZmluZQlQQUNLRVQzX1dBSVRfUkVHX01FTQkJCQkweDNDCisjZGVmaW5lCQlXQUlUX1JFR19NRU1fRlVOQ1RJT04oeCkgICAgICAgICAgICAgICAgKCh4KSA8PCAwKQorICAgICAgICAgICAgICAgIC8qIDAgLSBhbHdheXMKKwkJICogMSAtIDwKKwkJICogMiAtIDw9CisJCSAqIDMgLSA9PQorCQkgKiA0IC0gIT0KKwkJICogNSAtID49CisJCSAqIDYgLSA+CisJCSAqLworI2RlZmluZQkJV0FJVF9SRUdfTUVNX01FTV9TUEFDRSh4KSAgICAgICAgICAgICAgICgoeCkgPDwgNCkKKyAgICAgICAgICAgICAgICAvKiAwIC0gcmVnCisJCSAqIDEgLSBtZW0KKwkJICovCisjZGVmaW5lCQlXQUlUX1JFR19NRU1fRU5HSU5FKHgpICAgICAgICAgICAgICAgICAgKCh4KSA8PCA4KQorICAgICAgICAgICAgICAgIC8qIDAgLSBtZQorCQkgKiAxIC0gcGZwCisJCSAqLwogI2RlZmluZQlQQUNLRVQzX01FTV9XUklURQkJCQkweDNECiAjZGVmaW5lCVBBQ0tFVDNfUEZQX1NZTkNfTUUJCQkJMHg0MgogI2RlZmluZQlQQUNLRVQzX1NVUkZBQ0VfU1lOQwkJCQkweDQzCkBAIC0xMjcyLDYgKzEyODksMTMgQEAKIAkJCQkJICgxIDw8IDIxKSB8CQkJXAogCQkJCQkgKCgobikgJiAweEZGRkZGKSA8PCAwKSkKIAorI2RlZmluZSBETUFfU1JCTV9QT0xMX1BBQ0tFVAkJKCg5IDw8IDI4KSB8CQkJXAorCQkJCQkgKDEgPDwgMjcpIHwJCQlcCisJCQkJCSAoMSA8PCAyNikpCisKKyNkZWZpbmUgRE1BX1NSQk1fUkVBRF9QQUNLRVQJCSgoOSA8PCAyOCkgfAkJCVwKKwkJCQkJICgxIDw8IDI3KSkKKwogLyogYXN5bmMgRE1BIFBhY2tldCB0eXBlcyAqLwogI2RlZmluZQlETUFfUEFDS0VUX1dSSVRFCQkJCSAgMHgyCiAjZGVmaW5lCURNQV9QQUNLRVRfQ09QWQkJCQkJICAweDMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcjEwMC5jIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yMTAwLmMKaW5kZXggNzRmMDZkNS4uMjc5ODAxYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yMTAwLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yMTAwLmMKQEAgLTY0NCw2ICs2NDQsNyBAQAogCQlyZXR1cm4gcjsKIAlyZGV2LT5nYXJ0LnRhYmxlX3NpemUgPSByZGV2LT5nYXJ0Lm51bV9ncHVfcGFnZXMgKiA0OwogCXJkZXYtPmFzaWMtPmdhcnQudGxiX2ZsdXNoID0gJnIxMDBfcGNpX2dhcnRfdGxiX2ZsdXNoOworCXJkZXYtPmFzaWMtPmdhcnQuZ2V0X3BhZ2VfZW50cnkgPSAmcjEwMF9wY2lfZ2FydF9nZXRfcGFnZV9lbnRyeTsKIAlyZGV2LT5hc2ljLT5nYXJ0LnNldF9wYWdlID0gJnIxMDBfcGNpX2dhcnRfc2V0X3BhZ2U7CiAJcmV0dXJuIHJhZGVvbl9nYXJ0X3RhYmxlX3JhbV9hbGxvYyhyZGV2KTsKIH0KQEAgLTY4MSwxMSArNjgyLDE2IEBACiAJV1JFRzMyKFJBREVPTl9BSUNfSElfQUREUiwgMCk7CiB9CiAKK3VpbnQ2NF90IHIxMDBfcGNpX2dhcnRfZ2V0X3BhZ2VfZW50cnkodWludDY0X3QgYWRkciwgdWludDMyX3QgZmxhZ3MpCit7CisJcmV0dXJuIGFkZHI7Cit9CisKIHZvaWQgcjEwMF9wY2lfZ2FydF9zZXRfcGFnZShzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldiwgdW5zaWduZWQgaSwKLQkJCSAgICB1aW50NjRfdCBhZGRyLCB1aW50MzJfdCBmbGFncykKKwkJCSAgICB1aW50NjRfdCBlbnRyeSkKIHsKIAl1MzIgKmd0dCA9IHJkZXYtPmdhcnQucHRyOwotCWd0dFtpXSA9IGNwdV90b19sZTMyKGxvd2VyXzMyX2JpdHMoYWRkcikpOworCWd0dFtpXSA9IGNwdV90b19sZTMyKGxvd2VyXzMyX2JpdHMoZW50cnkpKTsKIH0KIAogdm9pZCByMTAwX3BjaV9nYXJ0X2Zpbmkoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3IzMDAuYyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcjMwMC5jCmluZGV4IDA2NGFkNTUuLjA4ZDY4ZjMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcjMwMC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcjMwMC5jCkBAIC03MywxMSArNzMsOCBAQAogI2RlZmluZSBSMzAwX1BURV9XUklURUFCTEUgKDEgPDwgMikKICNkZWZpbmUgUjMwMF9QVEVfUkVBREFCTEUgICgxIDw8IDMpCiAKLXZvaWQgcnYzNzBfcGNpZV9nYXJ0X3NldF9wYWdlKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2LCB1bnNpZ25lZCBpLAotCQkJICAgICAgdWludDY0X3QgYWRkciwgdWludDMyX3QgZmxhZ3MpCit1aW50NjRfdCBydjM3MF9wY2llX2dhcnRfZ2V0X3BhZ2VfZW50cnkodWludDY0X3QgYWRkciwgdWludDMyX3QgZmxhZ3MpCiB7Ci0Jdm9pZCBfX2lvbWVtICpwdHIgPSByZGV2LT5nYXJ0LnB0cjsKLQogCWFkZHIgPSAobG93ZXJfMzJfYml0cyhhZGRyKSA+PiA4KSB8CiAJCSgodXBwZXJfMzJfYml0cyhhZGRyKSAmIDB4ZmYpIDw8IDI0KTsKIAlpZiAoZmxhZ3MgJiBSQURFT05fR0FSVF9QQUdFX1JFQUQpCkBAIC04NiwxMCArODMsMTggQEAKIAkJYWRkciB8PSBSMzAwX1BURV9XUklURUFCTEU7CiAJaWYgKCEoZmxhZ3MgJiBSQURFT05fR0FSVF9QQUdFX1NOT09QKSkKIAkJYWRkciB8PSBSMzAwX1BURV9VTlNOT09QRUQ7CisJcmV0dXJuIGFkZHI7Cit9CisKK3ZvaWQgcnYzNzBfcGNpZV9nYXJ0X3NldF9wYWdlKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2LCB1bnNpZ25lZCBpLAorCQkJICAgICAgdWludDY0X3QgZW50cnkpCit7CisJdm9pZCBfX2lvbWVtICpwdHIgPSByZGV2LT5nYXJ0LnB0cjsKKwogCS8qIG9uIHg4NiB3ZSB3YW50IHRoaXMgdG8gYmUgQ1BVIGVuZGlhbiwgb24gcG93ZXJwYwogCSAqIG9uIHBvd2VycGMgd2l0aG91dCBIVyBzd2FwcGVycywgaXQnbGwgZ2V0IHN3YXBwZWQgb24gd2F5CiAJICogaW50byBWUkFNIC0gc28gbm8gbmVlZCBmb3IgY3B1X3RvX2xlMzIgb24gVlJBTSB0YWJsZXMgKi8KLQl3cml0ZWwoYWRkciwgKCh2b2lkIF9faW9tZW0gKilwdHIpICsgKGkgKiA0KSk7CisJd3JpdGVsKGVudHJ5LCAoKHZvaWQgX19pb21lbSAqKXB0cikgKyAoaSAqIDQpKTsKIH0KIAogaW50IHJ2MzcwX3BjaWVfZ2FydF9pbml0KHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2KQpAQCAtMTA5LDYgKzExNCw3IEBACiAJCURSTV9FUlJPUigiRmFpbGVkIHRvIHJlZ2lzdGVyIGRlYnVnZnMgZmlsZSBmb3IgUENJRSBnYXJ0ICFcbiIpOwogCXJkZXYtPmdhcnQudGFibGVfc2l6ZSA9IHJkZXYtPmdhcnQubnVtX2dwdV9wYWdlcyAqIDQ7CiAJcmRldi0+YXNpYy0+Z2FydC50bGJfZmx1c2ggPSAmcnYzNzBfcGNpZV9nYXJ0X3RsYl9mbHVzaDsKKwlyZGV2LT5hc2ljLT5nYXJ0LmdldF9wYWdlX2VudHJ5ID0gJnJ2MzcwX3BjaWVfZ2FydF9nZXRfcGFnZV9lbnRyeTsKIAlyZGV2LT5hc2ljLT5nYXJ0LnNldF9wYWdlID0gJnJ2MzcwX3BjaWVfZ2FydF9zZXRfcGFnZTsKIAlyZXR1cm4gcmFkZW9uX2dhcnRfdGFibGVfdnJhbV9hbGxvYyhyZGV2KTsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uLmggYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbi5oCmluZGV4IDU0NTI5YjguLjNmMmE4ZDMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uLmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb24uaApAQCAtMjQyLDYgKzI0Miw3IEBACiAgKiBEdW1teSBwYWdlCiAgKi8KIHN0cnVjdCByYWRlb25fZHVtbXlfcGFnZSB7CisJdWludDY0X3QJZW50cnk7CiAJc3RydWN0IHBhZ2UJKnBhZ2U7CiAJZG1hX2FkZHJfdAlhZGRyOwogfTsKQEAgLTY0NSw3ICs2NDYsNyBAQAogCXVuc2lnbmVkCQkJbnVtX2NwdV9wYWdlczsKIAl1bnNpZ25lZAkJCXRhYmxlX3NpemU7CiAJc3RydWN0IHBhZ2UJCQkqKnBhZ2VzOwotCWRtYV9hZGRyX3QJCQkqcGFnZXNfYWRkcjsKKwl1aW50NjRfdAkJCSpwYWdlc19lbnRyeTsKIAlib29sCQkJCXJlYWR5OwogfTsKIApAQCAtMTg0Nyw4ICsxODQ4LDkgQEAKIAkvKiBnYXJ0ICovCiAJc3RydWN0IHsKIAkJdm9pZCAoKnRsYl9mbHVzaCkoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpOworCQl1aW50NjRfdCAoKmdldF9wYWdlX2VudHJ5KSh1aW50NjRfdCBhZGRyLCB1aW50MzJfdCBmbGFncyk7CiAJCXZvaWQgKCpzZXRfcGFnZSkoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYsIHVuc2lnbmVkIGksCi0JCQkJIHVpbnQ2NF90IGFkZHIsIHVpbnQzMl90IGZsYWdzKTsKKwkJCQkgdWludDY0X3QgZW50cnkpOwogCX0gZ2FydDsKIAlzdHJ1Y3QgewogCQlpbnQgKCppbml0KShzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldik7CkBAIC0yODUyLDcgKzI4NTQsOCBAQAogI2RlZmluZSByYWRlb25fdmdhX3NldF9zdGF0ZShyZGV2LCBzdGF0ZSkgKHJkZXYpLT5hc2ljLT52Z2Ffc2V0X3N0YXRlKChyZGV2KSwgKHN0YXRlKSkKICNkZWZpbmUgcmFkZW9uX2FzaWNfcmVzZXQocmRldikgKHJkZXYpLT5hc2ljLT5hc2ljX3Jlc2V0KChyZGV2KSkKICNkZWZpbmUgcmFkZW9uX2dhcnRfdGxiX2ZsdXNoKHJkZXYpIChyZGV2KS0+YXNpYy0+Z2FydC50bGJfZmx1c2goKHJkZXYpKQotI2RlZmluZSByYWRlb25fZ2FydF9zZXRfcGFnZShyZGV2LCBpLCBwLCBmKSAocmRldiktPmFzaWMtPmdhcnQuc2V0X3BhZ2UoKHJkZXYpLCAoaSksIChwKSwgKGYpKQorI2RlZmluZSByYWRlb25fZ2FydF9nZXRfcGFnZV9lbnRyeShhLCBmKSAocmRldiktPmFzaWMtPmdhcnQuZ2V0X3BhZ2VfZW50cnkoKGEpLCAoZikpCisjZGVmaW5lIHJhZGVvbl9nYXJ0X3NldF9wYWdlKHJkZXYsIGksIGUpIChyZGV2KS0+YXNpYy0+Z2FydC5zZXRfcGFnZSgocmRldiksIChpKSwgKGUpKQogI2RlZmluZSByYWRlb25fYXNpY192bV9pbml0KHJkZXYpIChyZGV2KS0+YXNpYy0+dm0uaW5pdCgocmRldikpCiAjZGVmaW5lIHJhZGVvbl9hc2ljX3ZtX2ZpbmkocmRldikgKHJkZXYpLT5hc2ljLT52bS5maW5pKChyZGV2KSkKICNkZWZpbmUgcmFkZW9uX2FzaWNfdm1fY29weV9wYWdlcyhyZGV2LCBpYiwgcGUsIHNyYywgY291bnQpICgocmRldiktPmFzaWMtPnZtLmNvcHlfcGFnZXMoKHJkZXYpLCAoaWIpLCAocGUpLCAoc3JjKSwgKGNvdW50KSkpCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9hc2ljLmMgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9hc2ljLmMKaW5kZXggODUwZGU1Ny4uZWQwZTEwZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fYXNpYy5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2FzaWMuYwpAQCAtMTU5LDExICsxNTksMTMgQEAKIAkJRFJNX0lORk8oIkZvcmNpbmcgQUdQIHRvIFBDSUUgbW9kZVxuIik7CiAJCXJkZXYtPmZsYWdzIHw9IFJBREVPTl9JU19QQ0lFOwogCQlyZGV2LT5hc2ljLT5nYXJ0LnRsYl9mbHVzaCA9ICZydjM3MF9wY2llX2dhcnRfdGxiX2ZsdXNoOworCQlyZGV2LT5hc2ljLT5nYXJ0LmdldF9wYWdlX2VudHJ5ID0gJnJ2MzcwX3BjaWVfZ2FydF9nZXRfcGFnZV9lbnRyeTsKIAkJcmRldi0+YXNpYy0+Z2FydC5zZXRfcGFnZSA9ICZydjM3MF9wY2llX2dhcnRfc2V0X3BhZ2U7CiAJfSBlbHNlIHsKIAkJRFJNX0lORk8oIkZvcmNpbmcgQUdQIHRvIFBDSSBtb2RlXG4iKTsKIAkJcmRldi0+ZmxhZ3MgfD0gUkFERU9OX0lTX1BDSTsKIAkJcmRldi0+YXNpYy0+Z2FydC50bGJfZmx1c2ggPSAmcjEwMF9wY2lfZ2FydF90bGJfZmx1c2g7CisJCXJkZXYtPmFzaWMtPmdhcnQuZ2V0X3BhZ2VfZW50cnkgPSAmcjEwMF9wY2lfZ2FydF9nZXRfcGFnZV9lbnRyeTsKIAkJcmRldi0+YXNpYy0+Z2FydC5zZXRfcGFnZSA9ICZyMTAwX3BjaV9nYXJ0X3NldF9wYWdlOwogCX0KIAlyZGV2LT5tYy5ndHRfc2l6ZSA9IHJhZGVvbl9nYXJ0X3NpemUgKiAxMDI0ICogMTAyNDsKQEAgLTE5OSw2ICsyMDEsNyBAQAogCS5tY193YWl0X2Zvcl9pZGxlID0gJnIxMDBfbWNfd2FpdF9mb3JfaWRsZSwKIAkuZ2FydCA9IHsKIAkJLnRsYl9mbHVzaCA9ICZyMTAwX3BjaV9nYXJ0X3RsYl9mbHVzaCwKKwkJLmdldF9wYWdlX2VudHJ5ID0gJnIxMDBfcGNpX2dhcnRfZ2V0X3BhZ2VfZW50cnksCiAJCS5zZXRfcGFnZSA9ICZyMTAwX3BjaV9nYXJ0X3NldF9wYWdlLAogCX0sCiAJLnJpbmcgPSB7CkBAIC0yNjUsNiArMjY4LDcgQEAKIAkubWNfd2FpdF9mb3JfaWRsZSA9ICZyMTAwX21jX3dhaXRfZm9yX2lkbGUsCiAJLmdhcnQgPSB7CiAJCS50bGJfZmx1c2ggPSAmcjEwMF9wY2lfZ2FydF90bGJfZmx1c2gsCisJCS5nZXRfcGFnZV9lbnRyeSA9ICZyMTAwX3BjaV9nYXJ0X2dldF9wYWdlX2VudHJ5LAogCQkuc2V0X3BhZ2UgPSAmcjEwMF9wY2lfZ2FydF9zZXRfcGFnZSwKIAl9LAogCS5yaW5nID0gewpAQCAtMzMzLDYgKzMzNywyMCBAQAogCS5zZXRfd3B0ciA9ICZyMTAwX2dmeF9zZXRfd3B0ciwKIH07CiAKK3N0YXRpYyBzdHJ1Y3QgcmFkZW9uX2FzaWNfcmluZyBydjUxNV9nZnhfcmluZyA9IHsKKwkuaWJfZXhlY3V0ZSA9ICZyMTAwX3JpbmdfaWJfZXhlY3V0ZSwKKwkuZW1pdF9mZW5jZSA9ICZyMzAwX2ZlbmNlX3JpbmdfZW1pdCwKKwkuZW1pdF9zZW1hcGhvcmUgPSAmcjEwMF9zZW1hcGhvcmVfcmluZ19lbWl0LAorCS5jc19wYXJzZSA9ICZyMzAwX2NzX3BhcnNlLAorCS5yaW5nX3N0YXJ0ID0gJnJ2NTE1X3Jpbmdfc3RhcnQsCisJLnJpbmdfdGVzdCA9ICZyMTAwX3JpbmdfdGVzdCwKKwkuaWJfdGVzdCA9ICZyMTAwX2liX3Rlc3QsCisJLmlzX2xvY2t1cCA9ICZyMTAwX2dwdV9pc19sb2NrdXAsCisJLmdldF9ycHRyID0gJnIxMDBfZ2Z4X2dldF9ycHRyLAorCS5nZXRfd3B0ciA9ICZyMTAwX2dmeF9nZXRfd3B0ciwKKwkuc2V0X3dwdHIgPSAmcjEwMF9nZnhfc2V0X3dwdHIsCit9OworCiBzdGF0aWMgc3RydWN0IHJhZGVvbl9hc2ljIHIzMDBfYXNpYyA9IHsKIAkuaW5pdCA9ICZyMzAwX2luaXQsCiAJLmZpbmkgPSAmcjMwMF9maW5pLApAQCAtMzQ1LDYgKzM2Myw3IEBACiAJLm1jX3dhaXRfZm9yX2lkbGUgPSAmcjMwMF9tY193YWl0X2Zvcl9pZGxlLAogCS5nYXJ0ID0gewogCQkudGxiX2ZsdXNoID0gJnIxMDBfcGNpX2dhcnRfdGxiX2ZsdXNoLAorCQkuZ2V0X3BhZ2VfZW50cnkgPSAmcjEwMF9wY2lfZ2FydF9nZXRfcGFnZV9lbnRyeSwKIAkJLnNldF9wYWdlID0gJnIxMDBfcGNpX2dhcnRfc2V0X3BhZ2UsCiAJfSwKIAkucmluZyA9IHsKQEAgLTQxMSw2ICs0MzAsNyBAQAogCS5tY193YWl0X2Zvcl9pZGxlID0gJnIzMDBfbWNfd2FpdF9mb3JfaWRsZSwKIAkuZ2FydCA9IHsKIAkJLnRsYl9mbHVzaCA9ICZydjM3MF9wY2llX2dhcnRfdGxiX2ZsdXNoLAorCQkuZ2V0X3BhZ2VfZW50cnkgPSAmcnYzNzBfcGNpZV9nYXJ0X2dldF9wYWdlX2VudHJ5LAogCQkuc2V0X3BhZ2UgPSAmcnYzNzBfcGNpZV9nYXJ0X3NldF9wYWdlLAogCX0sCiAJLnJpbmcgPSB7CkBAIC00NzcsNiArNDk3LDcgQEAKIAkubWNfd2FpdF9mb3JfaWRsZSA9ICZyMzAwX21jX3dhaXRfZm9yX2lkbGUsCiAJLmdhcnQgPSB7CiAJCS50bGJfZmx1c2ggPSAmcnYzNzBfcGNpZV9nYXJ0X3RsYl9mbHVzaCwKKwkJLmdldF9wYWdlX2VudHJ5ID0gJnJ2MzcwX3BjaWVfZ2FydF9nZXRfcGFnZV9lbnRyeSwKIAkJLnNldF9wYWdlID0gJnJ2MzcwX3BjaWVfZ2FydF9zZXRfcGFnZSwKIAl9LAogCS5yaW5nID0gewpAQCAtNTQzLDYgKzU2NCw3IEBACiAJLm1jX3dhaXRfZm9yX2lkbGUgPSAmcnM0MDBfbWNfd2FpdF9mb3JfaWRsZSwKIAkuZ2FydCA9IHsKIAkJLnRsYl9mbHVzaCA9ICZyczQwMF9nYXJ0X3RsYl9mbHVzaCwKKwkJLmdldF9wYWdlX2VudHJ5ID0gJnJzNDAwX2dhcnRfZ2V0X3BhZ2VfZW50cnksCiAJCS5zZXRfcGFnZSA9ICZyczQwMF9nYXJ0X3NldF9wYWdlLAogCX0sCiAJLnJpbmcgPSB7CkBAIC02MDksNiArNjMxLDcgQEAKIAkubWNfd2FpdF9mb3JfaWRsZSA9ICZyczYwMF9tY193YWl0X2Zvcl9pZGxlLAogCS5nYXJ0ID0gewogCQkudGxiX2ZsdXNoID0gJnJzNjAwX2dhcnRfdGxiX2ZsdXNoLAorCQkuZ2V0X3BhZ2VfZW50cnkgPSAmcnM2MDBfZ2FydF9nZXRfcGFnZV9lbnRyeSwKIAkJLnNldF9wYWdlID0gJnJzNjAwX2dhcnRfc2V0X3BhZ2UsCiAJfSwKIAkucmluZyA9IHsKQEAgLTY3Nyw2ICs3MDAsNyBAQAogCS5tY193YWl0X2Zvcl9pZGxlID0gJnJzNjkwX21jX3dhaXRfZm9yX2lkbGUsCiAJLmdhcnQgPSB7CiAJCS50bGJfZmx1c2ggPSAmcnM0MDBfZ2FydF90bGJfZmx1c2gsCisJCS5nZXRfcGFnZV9lbnRyeSA9ICZyczQwMF9nYXJ0X2dldF9wYWdlX2VudHJ5LAogCQkuc2V0X3BhZ2UgPSAmcnM0MDBfZ2FydF9zZXRfcGFnZSwKIAl9LAogCS5yaW5nID0gewpAQCAtNzQ1LDEwICs3NjksMTEgQEAKIAkubWNfd2FpdF9mb3JfaWRsZSA9ICZydjUxNV9tY193YWl0X2Zvcl9pZGxlLAogCS5nYXJ0ID0gewogCQkudGxiX2ZsdXNoID0gJnJ2MzcwX3BjaWVfZ2FydF90bGJfZmx1c2gsCisJCS5nZXRfcGFnZV9lbnRyeSA9ICZydjM3MF9wY2llX2dhcnRfZ2V0X3BhZ2VfZW50cnksCiAJCS5zZXRfcGFnZSA9ICZydjM3MF9wY2llX2dhcnRfc2V0X3BhZ2UsCiAJfSwKIAkucmluZyA9IHsKLQkJW1JBREVPTl9SSU5HX1RZUEVfR0ZYX0lOREVYXSA9ICZyMzAwX2dmeF9yaW5nCisJCVtSQURFT05fUklOR19UWVBFX0dGWF9JTkRFWF0gPSAmcnY1MTVfZ2Z4X3JpbmcKIAl9LAogCS5pcnEgPSB7CiAJCS5zZXQgPSAmcnM2MDBfaXJxX3NldCwKQEAgLTgxMSwxMCArODM2LDExIEBACiAJLm1jX3dhaXRfZm9yX2lkbGUgPSAmcjUyMF9tY193YWl0X2Zvcl9pZGxlLAogCS5nYXJ0ID0gewogCQkudGxiX2ZsdXNoID0gJnJ2MzcwX3BjaWVfZ2FydF90bGJfZmx1c2gsCisJCS5nZXRfcGFnZV9lbnRyeSA9ICZydjM3MF9wY2llX2dhcnRfZ2V0X3BhZ2VfZW50cnksCiAJCS5zZXRfcGFnZSA9ICZydjM3MF9wY2llX2dhcnRfc2V0X3BhZ2UsCiAJfSwKIAkucmluZyA9IHsKLQkJW1JBREVPTl9SSU5HX1RZUEVfR0ZYX0lOREVYXSA9ICZyMzAwX2dmeF9yaW5nCisJCVtSQURFT05fUklOR19UWVBFX0dGWF9JTkRFWF0gPSAmcnY1MTVfZ2Z4X3JpbmcKIAl9LAogCS5pcnEgPSB7CiAJCS5zZXQgPSAmcnM2MDBfaXJxX3NldCwKQEAgLTkwNSw2ICs5MzEsNyBAQAogCS5nZXRfZ3B1X2Nsb2NrX2NvdW50ZXIgPSAmcjYwMF9nZXRfZ3B1X2Nsb2NrX2NvdW50ZXIsCiAJLmdhcnQgPSB7CiAJCS50bGJfZmx1c2ggPSAmcjYwMF9wY2llX2dhcnRfdGxiX2ZsdXNoLAorCQkuZ2V0X3BhZ2VfZW50cnkgPSAmcnM2MDBfZ2FydF9nZXRfcGFnZV9lbnRyeSwKIAkJLnNldF9wYWdlID0gJnJzNjAwX2dhcnRfc2V0X3BhZ2UsCiAJfSwKIAkucmluZyA9IHsKQEAgLTk5MCw2ICsxMDE3LDcgQEAKIAkuZ2V0X2dwdV9jbG9ja19jb3VudGVyID0gJnI2MDBfZ2V0X2dwdV9jbG9ja19jb3VudGVyLAogCS5nYXJ0ID0gewogCQkudGxiX2ZsdXNoID0gJnI2MDBfcGNpZV9nYXJ0X3RsYl9mbHVzaCwKKwkJLmdldF9wYWdlX2VudHJ5ID0gJnJzNjAwX2dhcnRfZ2V0X3BhZ2VfZW50cnksCiAJCS5zZXRfcGFnZSA9ICZyczYwMF9nYXJ0X3NldF9wYWdlLAogCX0sCiAJLnJpbmcgPSB7CkBAIC0xMDgxLDYgKzExMDksNyBAQAogCS5nZXRfZ3B1X2Nsb2NrX2NvdW50ZXIgPSAmcjYwMF9nZXRfZ3B1X2Nsb2NrX2NvdW50ZXIsCiAJLmdhcnQgPSB7CiAJCS50bGJfZmx1c2ggPSAmcjYwMF9wY2llX2dhcnRfdGxiX2ZsdXNoLAorCQkuZ2V0X3BhZ2VfZW50cnkgPSAmcnM2MDBfZ2FydF9nZXRfcGFnZV9lbnRyeSwKIAkJLnNldF9wYWdlID0gJnJzNjAwX2dhcnRfc2V0X3BhZ2UsCiAJfSwKIAkucmluZyA9IHsKQEAgLTExODUsNiArMTIxNCw3IEBACiAJLmdldF9ncHVfY2xvY2tfY291bnRlciA9ICZyNjAwX2dldF9ncHVfY2xvY2tfY291bnRlciwKIAkuZ2FydCA9IHsKIAkJLnRsYl9mbHVzaCA9ICZyNjAwX3BjaWVfZ2FydF90bGJfZmx1c2gsCisJCS5nZXRfcGFnZV9lbnRyeSA9ICZyczYwMF9nYXJ0X2dldF9wYWdlX2VudHJ5LAogCQkuc2V0X3BhZ2UgPSAmcnM2MDBfZ2FydF9zZXRfcGFnZSwKIAl9LAogCS5yaW5nID0gewpAQCAtMTMwMyw2ICsxMzMzLDcgQEAKIAkuZ2V0X2dwdV9jbG9ja19jb3VudGVyID0gJnI2MDBfZ2V0X2dwdV9jbG9ja19jb3VudGVyLAogCS5nYXJ0ID0gewogCQkudGxiX2ZsdXNoID0gJmV2ZXJncmVlbl9wY2llX2dhcnRfdGxiX2ZsdXNoLAorCQkuZ2V0X3BhZ2VfZW50cnkgPSAmcnM2MDBfZ2FydF9nZXRfcGFnZV9lbnRyeSwKIAkJLnNldF9wYWdlID0gJnJzNjAwX2dhcnRfc2V0X3BhZ2UsCiAJfSwKIAkucmluZyA9IHsKQEAgLTEzOTUsNiArMTQyNiw3IEBACiAJLmdldF9ncHVfY2xvY2tfY291bnRlciA9ICZyNjAwX2dldF9ncHVfY2xvY2tfY291bnRlciwKIAkuZ2FydCA9IHsKIAkJLnRsYl9mbHVzaCA9ICZldmVyZ3JlZW5fcGNpZV9nYXJ0X3RsYl9mbHVzaCwKKwkJLmdldF9wYWdlX2VudHJ5ID0gJnJzNjAwX2dhcnRfZ2V0X3BhZ2VfZW50cnksCiAJCS5zZXRfcGFnZSA9ICZyczYwMF9nYXJ0X3NldF9wYWdlLAogCX0sCiAJLnJpbmcgPSB7CkBAIC0xNDg2LDYgKzE1MTgsNyBAQAogCS5nZXRfZ3B1X2Nsb2NrX2NvdW50ZXIgPSAmcjYwMF9nZXRfZ3B1X2Nsb2NrX2NvdW50ZXIsCiAJLmdhcnQgPSB7CiAJCS50bGJfZmx1c2ggPSAmZXZlcmdyZWVuX3BjaWVfZ2FydF90bGJfZmx1c2gsCisJCS5nZXRfcGFnZV9lbnRyeSA9ICZyczYwMF9nYXJ0X2dldF9wYWdlX2VudHJ5LAogCQkuc2V0X3BhZ2UgPSAmcnM2MDBfZ2FydF9zZXRfcGFnZSwKIAl9LAogCS5yaW5nID0gewpAQCAtMTYyMSw2ICsxNjU0LDcgQEAKIAkuZ2V0X2dwdV9jbG9ja19jb3VudGVyID0gJnI2MDBfZ2V0X2dwdV9jbG9ja19jb3VudGVyLAogCS5nYXJ0ID0gewogCQkudGxiX2ZsdXNoID0gJmNheW1hbl9wY2llX2dhcnRfdGxiX2ZsdXNoLAorCQkuZ2V0X3BhZ2VfZW50cnkgPSAmcnM2MDBfZ2FydF9nZXRfcGFnZV9lbnRyeSwKIAkJLnNldF9wYWdlID0gJnJzNjAwX2dhcnRfc2V0X3BhZ2UsCiAJfSwKIAkudm0gPSB7CkBAIC0xNzI0LDYgKzE3NTgsNyBAQAogCS5nZXRfZ3B1X2Nsb2NrX2NvdW50ZXIgPSAmcjYwMF9nZXRfZ3B1X2Nsb2NrX2NvdW50ZXIsCiAJLmdhcnQgPSB7CiAJCS50bGJfZmx1c2ggPSAmY2F5bWFuX3BjaWVfZ2FydF90bGJfZmx1c2gsCisJCS5nZXRfcGFnZV9lbnRyeSA9ICZyczYwMF9nYXJ0X2dldF9wYWdlX2VudHJ5LAogCQkuc2V0X3BhZ2UgPSAmcnM2MDBfZ2FydF9zZXRfcGFnZSwKIAl9LAogCS52bSA9IHsKQEAgLTE4NTcsNiArMTg5Miw3IEBACiAJLmdldF9ncHVfY2xvY2tfY291bnRlciA9ICZzaV9nZXRfZ3B1X2Nsb2NrX2NvdW50ZXIsCiAJLmdhcnQgPSB7CiAJCS50bGJfZmx1c2ggPSAmc2lfcGNpZV9nYXJ0X3RsYl9mbHVzaCwKKwkJLmdldF9wYWdlX2VudHJ5ID0gJnJzNjAwX2dhcnRfZ2V0X3BhZ2VfZW50cnksCiAJCS5zZXRfcGFnZSA9ICZyczYwMF9nYXJ0X3NldF9wYWdlLAogCX0sCiAJLnZtID0gewpAQCAtMjAxOCw2ICsyMDU0LDcgQEAKIAkuZ2V0X2dwdV9jbG9ja19jb3VudGVyID0gJmNpa19nZXRfZ3B1X2Nsb2NrX2NvdW50ZXIsCiAJLmdhcnQgPSB7CiAJCS50bGJfZmx1c2ggPSAmY2lrX3BjaWVfZ2FydF90bGJfZmx1c2gsCisJCS5nZXRfcGFnZV9lbnRyeSA9ICZyczYwMF9nYXJ0X2dldF9wYWdlX2VudHJ5LAogCQkuc2V0X3BhZ2UgPSAmcnM2MDBfZ2FydF9zZXRfcGFnZSwKIAl9LAogCS52bSA9IHsKQEAgLTIxMjUsNiArMjE2Miw3IEBACiAJLmdldF9ncHVfY2xvY2tfY291bnRlciA9ICZjaWtfZ2V0X2dwdV9jbG9ja19jb3VudGVyLAogCS5nYXJ0ID0gewogCQkudGxiX2ZsdXNoID0gJmNpa19wY2llX2dhcnRfdGxiX2ZsdXNoLAorCQkuZ2V0X3BhZ2VfZW50cnkgPSAmcnM2MDBfZ2FydF9nZXRfcGFnZV9lbnRyeSwKIAkJLnNldF9wYWdlID0gJnJzNjAwX2dhcnRfc2V0X3BhZ2UsCiAJfSwKIAkudm0gPSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9hc2ljLmggYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9hc2ljLmgKaW5kZXggMmE0NWQ1NC4uOGQ3ODdkMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fYXNpYy5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2FzaWMuaApAQCAtNjcsOCArNjcsOSBAQAogaW50IHIxMDBfYXNpY19yZXNldChzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldik7CiB1MzIgcjEwMF9nZXRfdmJsYW5rX2NvdW50ZXIoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYsIGludCBjcnRjKTsKIHZvaWQgcjEwMF9wY2lfZ2FydF90bGJfZmx1c2goc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpOwordWludDY0X3QgcjEwMF9wY2lfZ2FydF9nZXRfcGFnZV9lbnRyeSh1aW50NjRfdCBhZGRyLCB1aW50MzJfdCBmbGFncyk7CiB2b2lkIHIxMDBfcGNpX2dhcnRfc2V0X3BhZ2Uoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYsIHVuc2lnbmVkIGksCi0JCQkgICAgdWludDY0X3QgYWRkciwgdWludDMyX3QgZmxhZ3MpOworCQkJICAgIHVpbnQ2NF90IGVudHJ5KTsKIHZvaWQgcjEwMF9yaW5nX3N0YXJ0KHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2LCBzdHJ1Y3QgcmFkZW9uX3JpbmcgKnJpbmcpOwogaW50IHIxMDBfaXJxX3NldChzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldik7CiBpbnQgcjEwMF9pcnFfcHJvY2VzcyhzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldik7CkBAIC0xNzIsOCArMTczLDkgQEAKIAkJCQlzdHJ1Y3QgcmFkZW9uX2ZlbmNlICpmZW5jZSk7CiBleHRlcm4gaW50IHIzMDBfY3NfcGFyc2Uoc3RydWN0IHJhZGVvbl9jc19wYXJzZXIgKnApOwogZXh0ZXJuIHZvaWQgcnYzNzBfcGNpZV9nYXJ0X3RsYl9mbHVzaChzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldik7CitleHRlcm4gdWludDY0X3QgcnYzNzBfcGNpZV9nYXJ0X2dldF9wYWdlX2VudHJ5KHVpbnQ2NF90IGFkZHIsIHVpbnQzMl90IGZsYWdzKTsKIGV4dGVybiB2b2lkIHJ2MzcwX3BjaWVfZ2FydF9zZXRfcGFnZShzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldiwgdW5zaWduZWQgaSwKLQkJCQkgICAgIHVpbnQ2NF90IGFkZHIsIHVpbnQzMl90IGZsYWdzKTsKKwkJCQkgICAgIHVpbnQ2NF90IGVudHJ5KTsKIGV4dGVybiB2b2lkIHJ2MzcwX3NldF9wY2llX2xhbmVzKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2LCBpbnQgbGFuZXMpOwogZXh0ZXJuIGludCBydjM3MF9nZXRfcGNpZV9sYW5lcyhzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldik7CiBleHRlcm4gdm9pZCByMzAwX3NldF9yZWdfc2FmZShzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldik7CkBAIC0yMDgsOCArMjEwLDkgQEAKIGV4dGVybiBpbnQgcnM0MDBfc3VzcGVuZChzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldik7CiBleHRlcm4gaW50IHJzNDAwX3Jlc3VtZShzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldik7CiB2b2lkIHJzNDAwX2dhcnRfdGxiX2ZsdXNoKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2KTsKK3VpbnQ2NF90IHJzNDAwX2dhcnRfZ2V0X3BhZ2VfZW50cnkodWludDY0X3QgYWRkciwgdWludDMyX3QgZmxhZ3MpOwogdm9pZCByczQwMF9nYXJ0X3NldF9wYWdlKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2LCB1bnNpZ25lZCBpLAotCQkJIHVpbnQ2NF90IGFkZHIsIHVpbnQzMl90IGZsYWdzKTsKKwkJCSB1aW50NjRfdCBlbnRyeSk7CiB1aW50MzJfdCByczQwMF9tY19ycmVnKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2LCB1aW50MzJfdCByZWcpOwogdm9pZCByczQwMF9tY193cmVnKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2LCB1aW50MzJfdCByZWcsIHVpbnQzMl90IHYpOwogaW50IHJzNDAwX2dhcnRfaW5pdChzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldik7CkBAIC0yMzIsOCArMjM1LDkgQEAKIHZvaWQgcnM2MDBfaXJxX2Rpc2FibGUoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpOwogdTMyIHJzNjAwX2dldF92YmxhbmtfY291bnRlcihzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldiwgaW50IGNydGMpOwogdm9pZCByczYwMF9nYXJ0X3RsYl9mbHVzaChzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldik7Cit1aW50NjRfdCByczYwMF9nYXJ0X2dldF9wYWdlX2VudHJ5KHVpbnQ2NF90IGFkZHIsIHVpbnQzMl90IGZsYWdzKTsKIHZvaWQgcnM2MDBfZ2FydF9zZXRfcGFnZShzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldiwgdW5zaWduZWQgaSwKLQkJCSB1aW50NjRfdCBhZGRyLCB1aW50MzJfdCBmbGFncyk7CisJCQkgdWludDY0X3QgZW50cnkpOwogdWludDMyX3QgcnM2MDBfbWNfcnJlZyhzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldiwgdWludDMyX3QgcmVnKTsKIHZvaWQgcnM2MDBfbWNfd3JlZyhzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldiwgdWludDMyX3QgcmVnLCB1aW50MzJfdCB2KTsKIHZvaWQgcnM2MDBfYmFuZHdpZHRoX3VwZGF0ZShzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9iZW5jaG1hcmsuYyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2JlbmNobWFyay5jCmluZGV4IDllN2YyM2RkLi44N2Q1ZmIyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9iZW5jaG1hcmsuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9iZW5jaG1hcmsuYwpAQCAtMzQsNyArMzQsOCBAQAogCiBzdGF0aWMgaW50IHJhZGVvbl9iZW5jaG1hcmtfZG9fbW92ZShzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldiwgdW5zaWduZWQgc2l6ZSwKIAkJCQkgICAgdWludDY0X3Qgc2FkZHIsIHVpbnQ2NF90IGRhZGRyLAotCQkJCSAgICBpbnQgZmxhZywgaW50IG4pCisJCQkJICAgIGludCBmbGFnLCBpbnQgbiwKKwkJCQkgICAgc3RydWN0IHJlc2VydmF0aW9uX29iamVjdCAqcmVzdikKIHsKIAl1bnNpZ25lZCBsb25nIHN0YXJ0X2ppZmZpZXM7CiAJdW5zaWduZWQgbG9uZyBlbmRfamlmZmllczsKQEAgLTQ3LDEyICs0OCwxMiBAQAogCQljYXNlIFJBREVPTl9CRU5DSE1BUktfQ09QWV9ETUE6CiAJCQlmZW5jZSA9IHJhZGVvbl9jb3B5X2RtYShyZGV2LCBzYWRkciwgZGFkZHIsCiAJCQkJCQlzaXplIC8gUkFERU9OX0dQVV9QQUdFX1NJWkUsCi0JCQkJCQlOVUxMKTsKKwkJCQkJCXJlc3YpOwogCQkJYnJlYWs7CiAJCWNhc2UgUkFERU9OX0JFTkNITUFSS19DT1BZX0JMSVQ6CiAJCQlmZW5jZSA9IHJhZGVvbl9jb3B5X2JsaXQocmRldiwgc2FkZHIsIGRhZGRyLAogCQkJCQkJIHNpemUgLyBSQURFT05fR1BVX1BBR0VfU0laRSwKLQkJCQkJCSBOVUxMKTsKKwkJCQkJCSByZXN2KTsKIAkJCWJyZWFrOwogCQlkZWZhdWx0OgogCQkJRFJNX0VSUk9SKCJVbmtub3duIGNvcHkgbWV0aG9kXG4iKTsKQEAgLTEyMCw3ICsxMjEsOCBAQAogCiAJaWYgKHJkZXYtPmFzaWMtPmNvcHkuZG1hKSB7CiAJCXRpbWUgPSByYWRlb25fYmVuY2htYXJrX2RvX21vdmUocmRldiwgc2l6ZSwgc2FkZHIsIGRhZGRyLAotCQkJCQkJUkFERU9OX0JFTkNITUFSS19DT1BZX0RNQSwgbik7CisJCQkJCQlSQURFT05fQkVOQ0hNQVJLX0NPUFlfRE1BLCBuLAorCQkJCQkJZG9iai0+dGJvLnJlc3YpOwogCQlpZiAodGltZSA8IDApCiAJCQlnb3RvIG91dF9jbGVhbnVwOwogCQlpZiAodGltZSA+IDApCkBAIC0xMzAsNyArMTMyLDggQEAKIAogCWlmIChyZGV2LT5hc2ljLT5jb3B5LmJsaXQpIHsKIAkJdGltZSA9IHJhZGVvbl9iZW5jaG1hcmtfZG9fbW92ZShyZGV2LCBzaXplLCBzYWRkciwgZGFkZHIsCi0JCQkJCQlSQURFT05fQkVOQ0hNQVJLX0NPUFlfQkxJVCwgbik7CisJCQkJCQlSQURFT05fQkVOQ0hNQVJLX0NPUFlfQkxJVCwgbiwKKwkJCQkJCWRvYmotPnRiby5yZXN2KTsKIAkJaWYgKHRpbWUgPCAwKQogCQkJZ290byBvdXRfY2xlYW51cDsKIAkJaWYgKHRpbWUgPiAwKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fZGV2aWNlLmMgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9kZXZpY2UuYwppbmRleCAwZWM2NTE2Li5iZDc1MTlmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9kZXZpY2UuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9kZXZpY2UuYwpAQCAtNzc0LDYgKzc3NCw4IEBACiAJCXJkZXYtPmR1bW15X3BhZ2UucGFnZSA9IE5VTEw7CiAJCXJldHVybiAtRU5PTUVNOwogCX0KKwlyZGV2LT5kdW1teV9wYWdlLmVudHJ5ID0gcmFkZW9uX2dhcnRfZ2V0X3BhZ2VfZW50cnkocmRldi0+ZHVtbXlfcGFnZS5hZGRyLAorCQkJCQkJCSAgICBSQURFT05fR0FSVF9QQUdFX0RVTU1ZKTsKIAlyZXR1cm4gMDsKIH0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fZGlzcGxheS5jIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fZGlzcGxheS5jCmluZGV4IDEwMjExNjkuLjkxM2ZhZmEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2Rpc3BsYXkuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9kaXNwbGF5LmMKQEAgLTk2MCw2ICs5NjAsOSBAQAogCWlmIChwbGwtPmZsYWdzICYgUkFERU9OX1BMTF9VU0VfRlJBQ19GQl9ESVYgJiYKIAkgICAgcGxsLT5mbGFncyAmIFJBREVPTl9QTExfVVNFX1JFRl9ESVYpCiAJCXJlZl9kaXZfbWF4ID0gcGxsLT5yZWZlcmVuY2VfZGl2OworCWVsc2UgaWYgKHBsbC0+ZmxhZ3MgJiBSQURFT05fUExMX1BSRUZFUl9NSU5NX09WRVJfTUFYUCkKKwkJLyogZml4IGZvciBwcm9ibGVtcyBvbiBSUzg4MCAqLworCQlyZWZfZGl2X21heCA9IG1pbihwbGwtPm1heF9yZWZfZGl2LCA3dSk7CiAJZWxzZQogCQlyZWZfZGl2X21heCA9IHBsbC0+bWF4X3JlZl9kaXY7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2dhcnQuYyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2dhcnQuYwppbmRleCA4NDE0NmQ1Li41NDUwZmE5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9nYXJ0LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fZ2FydC5jCkBAIC0xNjUsNiArMTY1LDE5IEBACiAJCXJhZGVvbl9ib191bnBpbihyZGV2LT5nYXJ0LnJvYmopOwogCXJhZGVvbl9ib191bnJlc2VydmUocmRldi0+Z2FydC5yb2JqKTsKIAlyZGV2LT5nYXJ0LnRhYmxlX2FkZHIgPSBncHVfYWRkcjsKKworCWlmICghcikgeworCQlpbnQgaTsKKworCQkvKiBXZSBtaWdodCBoYXZlIGRyb3BwZWQgc29tZSBHQVJUIHRhYmxlIHVwZGF0ZXMgd2hpbGUgaXQgd2Fzbid0CisJCSAqIG1hcHBlZCwgcmVzdG9yZSBhbGwgZW50cmllcworCQkgKi8KKwkJZm9yIChpID0gMDsgaSA8IHJkZXYtPmdhcnQubnVtX2dwdV9wYWdlczsgaSsrKQorCQkJcmFkZW9uX2dhcnRfc2V0X3BhZ2UocmRldiwgaSwgcmRldi0+Z2FydC5wYWdlc19lbnRyeVtpXSk7CisJCW1iKCk7CisJCXJhZGVvbl9nYXJ0X3RsYl9mbHVzaChyZGV2KTsKKwl9CisKIAlyZXR1cm4gcjsKIH0KIApAQCAtMjI4LDcgKzI0MSw2IEBACiAJdW5zaWduZWQgdDsKIAl1bnNpZ25lZCBwOwogCWludCBpLCBqOwotCXU2NCBwYWdlX2Jhc2U7CiAKIAlpZiAoIXJkZXYtPmdhcnQucmVhZHkpIHsKIAkJV0FSTigxLCAidHJ5aW5nIHRvIHVuYmluZCBtZW1vcnkgZnJvbSB1bmluaXRpYWxpemVkIEdBUlQgIVxuIik7CkBAIC0yMzksMTQgKzI1MSwxMiBAQAogCWZvciAoaSA9IDA7IGkgPCBwYWdlczsgaSsrLCBwKyspIHsKIAkJaWYgKHJkZXYtPmdhcnQucGFnZXNbcF0pIHsKIAkJCXJkZXYtPmdhcnQucGFnZXNbcF0gPSBOVUxMOwotCQkJcmRldi0+Z2FydC5wYWdlc19hZGRyW3BdID0gcmRldi0+ZHVtbXlfcGFnZS5hZGRyOwotCQkJcGFnZV9iYXNlID0gcmRldi0+Z2FydC5wYWdlc19hZGRyW3BdOwogCQkJZm9yIChqID0gMDsgaiA8IChQQUdFX1NJWkUgLyBSQURFT05fR1BVX1BBR0VfU0laRSk7IGorKywgdCsrKSB7CisJCQkJcmRldi0+Z2FydC5wYWdlc19lbnRyeVt0XSA9IHJkZXYtPmR1bW15X3BhZ2UuZW50cnk7CiAJCQkJaWYgKHJkZXYtPmdhcnQucHRyKSB7Ci0JCQkJCXJhZGVvbl9nYXJ0X3NldF9wYWdlKHJkZXYsIHQsIHBhZ2VfYmFzZSwKLQkJCQkJCQkgICAgIFJBREVPTl9HQVJUX1BBR0VfRFVNTVkpOworCQkJCQlyYWRlb25fZ2FydF9zZXRfcGFnZShyZGV2LCB0LAorCQkJCQkJCSAgICAgcmRldi0+ZHVtbXlfcGFnZS5lbnRyeSk7CiAJCQkJfQotCQkJCXBhZ2VfYmFzZSArPSBSQURFT05fR1BVX1BBR0VfU0laRTsKIAkJCX0KIAkJfQogCX0KQEAgLTI3NCw3ICsyODQsNyBAQAogewogCXVuc2lnbmVkIHQ7CiAJdW5zaWduZWQgcDsKLQl1aW50NjRfdCBwYWdlX2Jhc2U7CisJdWludDY0X3QgcGFnZV9iYXNlLCBwYWdlX2VudHJ5OwogCWludCBpLCBqOwogCiAJaWYgKCFyZGV2LT5nYXJ0LnJlYWR5KSB7CkBAIC0yODUsMTQgKzI5NSwxNSBAQAogCXAgPSB0IC8gKFBBR0VfU0laRSAvIFJBREVPTl9HUFVfUEFHRV9TSVpFKTsKIAogCWZvciAoaSA9IDA7IGkgPCBwYWdlczsgaSsrLCBwKyspIHsKLQkJcmRldi0+Z2FydC5wYWdlc19hZGRyW3BdID0gZG1hX2FkZHJbaV07CiAJCXJkZXYtPmdhcnQucGFnZXNbcF0gPSBwYWdlbGlzdFtpXTsKLQkJaWYgKHJkZXYtPmdhcnQucHRyKSB7Ci0JCQlwYWdlX2Jhc2UgPSByZGV2LT5nYXJ0LnBhZ2VzX2FkZHJbcF07Ci0JCQlmb3IgKGogPSAwOyBqIDwgKFBBR0VfU0laRSAvIFJBREVPTl9HUFVfUEFHRV9TSVpFKTsgaisrLCB0KyspIHsKLQkJCQlyYWRlb25fZ2FydF9zZXRfcGFnZShyZGV2LCB0LCBwYWdlX2Jhc2UsIGZsYWdzKTsKLQkJCQlwYWdlX2Jhc2UgKz0gUkFERU9OX0dQVV9QQUdFX1NJWkU7CisJCXBhZ2VfYmFzZSA9IGRtYV9hZGRyW2ldOworCQlmb3IgKGogPSAwOyBqIDwgKFBBR0VfU0laRSAvIFJBREVPTl9HUFVfUEFHRV9TSVpFKTsgaisrLCB0KyspIHsKKwkJCXBhZ2VfZW50cnkgPSByYWRlb25fZ2FydF9nZXRfcGFnZV9lbnRyeShwYWdlX2Jhc2UsIGZsYWdzKTsKKwkJCXJkZXYtPmdhcnQucGFnZXNfZW50cnlbdF0gPSBwYWdlX2VudHJ5OworCQkJaWYgKHJkZXYtPmdhcnQucHRyKSB7CisJCQkJcmFkZW9uX2dhcnRfc2V0X3BhZ2UocmRldiwgdCwgcGFnZV9lbnRyeSk7CiAJCQl9CisJCQlwYWdlX2Jhc2UgKz0gUkFERU9OX0dQVV9QQUdFX1NJWkU7CiAJCX0KIAl9CiAJbWIoKTsKQEAgLTMzNCwxNiArMzQ1LDE1IEBACiAJCXJhZGVvbl9nYXJ0X2ZpbmkocmRldik7CiAJCXJldHVybiAtRU5PTUVNOwogCX0KLQlyZGV2LT5nYXJ0LnBhZ2VzX2FkZHIgPSB2emFsbG9jKHNpemVvZihkbWFfYWRkcl90KSAqCi0JCQkJCXJkZXYtPmdhcnQubnVtX2NwdV9wYWdlcyk7Ci0JaWYgKHJkZXYtPmdhcnQucGFnZXNfYWRkciA9PSBOVUxMKSB7CisJcmRldi0+Z2FydC5wYWdlc19lbnRyeSA9IHZtYWxsb2Moc2l6ZW9mKHVpbnQ2NF90KSAqCisJCQkJCSByZGV2LT5nYXJ0Lm51bV9ncHVfcGFnZXMpOworCWlmIChyZGV2LT5nYXJ0LnBhZ2VzX2VudHJ5ID09IE5VTEwpIHsKIAkJcmFkZW9uX2dhcnRfZmluaShyZGV2KTsKIAkJcmV0dXJuIC1FTk9NRU07CiAJfQogCS8qIHNldCBHQVJUIGVudHJ5IHRvIHBvaW50IHRvIHRoZSBkdW1teSBwYWdlIGJ5IGRlZmF1bHQgKi8KLQlmb3IgKGkgPSAwOyBpIDwgcmRldi0+Z2FydC5udW1fY3B1X3BhZ2VzOyBpKyspIHsKLQkJcmRldi0+Z2FydC5wYWdlc19hZGRyW2ldID0gcmRldi0+ZHVtbXlfcGFnZS5hZGRyOwotCX0KKwlmb3IgKGkgPSAwOyBpIDwgcmRldi0+Z2FydC5udW1fZ3B1X3BhZ2VzOyBpKyspCisJCXJkZXYtPmdhcnQucGFnZXNfZW50cnlbaV0gPSByZGV2LT5kdW1teV9wYWdlLmVudHJ5OwogCXJldHVybiAwOwogfQogCkBAIC0zNTYsMTUgKzM2NiwxNSBAQAogICovCiB2b2lkIHJhZGVvbl9nYXJ0X2Zpbmkoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpCiB7Ci0JaWYgKHJkZXYtPmdhcnQucGFnZXMgJiYgcmRldi0+Z2FydC5wYWdlc19hZGRyICYmIHJkZXYtPmdhcnQucmVhZHkpIHsKKwlpZiAocmRldi0+Z2FydC5yZWFkeSkgewogCQkvKiB1bmJpbmQgcGFnZXMgKi8KIAkJcmFkZW9uX2dhcnRfdW5iaW5kKHJkZXYsIDAsIHJkZXYtPmdhcnQubnVtX2NwdV9wYWdlcyk7CiAJfQogCXJkZXYtPmdhcnQucmVhZHkgPSBmYWxzZTsKIAl2ZnJlZShyZGV2LT5nYXJ0LnBhZ2VzKTsKLQl2ZnJlZShyZGV2LT5nYXJ0LnBhZ2VzX2FkZHIpOworCXZmcmVlKHJkZXYtPmdhcnQucGFnZXNfZW50cnkpOwogCXJkZXYtPmdhcnQucGFnZXMgPSBOVUxMOwotCXJkZXYtPmdhcnQucGFnZXNfYWRkciA9IE5VTEw7CisJcmRldi0+Z2FydC5wYWdlc19lbnRyeSA9IE5VTEw7CiAKIAlyYWRlb25fZHVtbXlfcGFnZV9maW5pKHJkZXYpOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fZ2VtLmMgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9nZW0uYwppbmRleCBhNDZmNzM3Li5hYzNjMTMxIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9nZW0uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9nZW0uYwpAQCAtMTQ2LDcgKzE0Niw4IEBACiAJc3RydWN0IHJhZGVvbl9ib192YSAqYm9fdmE7CiAJaW50IHI7CiAKLQlpZiAocmRldi0+ZmFtaWx5IDwgQ0hJUF9DQVlNQU4pIHsKKwlpZiAoKHJkZXYtPmZhbWlseSA8IENISVBfQ0FZTUFOKSB8fAorCSAgICAoIXJkZXYtPmFjY2VsX3dvcmtpbmcpKSB7CiAJCXJldHVybiAwOwogCX0KIApAQCAtMTc2LDcgKzE3Nyw4IEBACiAJc3RydWN0IHJhZGVvbl9ib192YSAqYm9fdmE7CiAJaW50IHI7CiAKLQlpZiAocmRldi0+ZmFtaWx5IDwgQ0hJUF9DQVlNQU4pIHsKKwlpZiAoKHJkZXYtPmZhbWlseSA8IENISVBfQ0FZTUFOKSB8fAorCSAgICAoIXJkZXYtPmFjY2VsX3dvcmtpbmcpKSB7CiAJCXJldHVybjsKIAl9CiAKQEAgLTU3Niw3ICs1NzgsNyBAQAogZXJyb3JfZnJlZToKIAlkcm1fZnJlZV9sYXJnZSh2bV9ib3MpOwogCi0JaWYgKHIpCisJaWYgKHIgJiYgciAhPSAtRVJFU1RBUlRTWVMpCiAJCURSTV9FUlJPUigiQ291bGRuJ3QgdXBkYXRlIEJPX1ZBICglZClcbiIsIHIpOwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9rZmQuYyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2tmZC5jCmluZGV4IDhiZjg3ZjEuLmJlZjlhMDkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2tmZC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2tmZC5jCkBAIC00MzYsNyArNDM2LDcgQEAKIHN0YXRpYyBpbnQga2dkX2luaXRfcGlwZWxpbmUoc3RydWN0IGtnZF9kZXYgKmtnZCwgdWludDMyX3QgcGlwZV9pZCwKIAkJCQl1aW50MzJfdCBocGRfc2l6ZSwgdWludDY0X3QgaHBkX2dwdV9hZGRyKQogewotCXVpbnQzMl90IG1lYyA9ICgrK3BpcGVfaWQgLyBDSUtfUElQRV9QRVJfTUVDKSArIDE7CisJdWludDMyX3QgbWVjID0gKHBpcGVfaWQgLyBDSUtfUElQRV9QRVJfTUVDKSArIDE7CiAJdWludDMyX3QgcGlwZSA9IChwaXBlX2lkICUgQ0lLX1BJUEVfUEVSX01FQyk7CiAKIAlsb2NrX3NyYm0oa2dkLCBtZWMsIHBpcGUsIDAsIDApOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fa21zLmMgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9rbXMuYwppbmRleCAzY2Y5YzFmLi42ODY0MTFlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9rbXMuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9rbXMuYwpAQCAtNjA1LDE0ICs2MDUsMTQgQEAKIAkJCXJldHVybiAtRU5PTUVNOwogCQl9CiAKLQkJdm0gPSAmZnByaXYtPnZtOwotCQlyID0gcmFkZW9uX3ZtX2luaXQocmRldiwgdm0pOwotCQlpZiAocikgewotCQkJa2ZyZWUoZnByaXYpOwotCQkJcmV0dXJuIHI7Ci0JCX0KLQogCQlpZiAocmRldi0+YWNjZWxfd29ya2luZykgeworCQkJdm0gPSAmZnByaXYtPnZtOworCQkJciA9IHJhZGVvbl92bV9pbml0KHJkZXYsIHZtKTsKKwkJCWlmIChyKSB7CisJCQkJa2ZyZWUoZnByaXYpOworCQkJCXJldHVybiByOworCQkJfQorCiAJCQlyID0gcmFkZW9uX2JvX3Jlc2VydmUocmRldi0+cmluZ190bXBfYm8uYm8sIGZhbHNlKTsKIAkJCWlmIChyKSB7CiAJCQkJcmFkZW9uX3ZtX2ZpbmkocmRldiwgdm0pOwpAQCAtNjY4LDkgKzY2OCw5IEBACiAJCQkJCXJhZGVvbl92bV9ib19ybXYocmRldiwgdm0tPmliX2JvX3ZhKTsKIAkJCQlyYWRlb25fYm9fdW5yZXNlcnZlKHJkZXYtPnJpbmdfdG1wX2JvLmJvKTsKIAkJCX0KKwkJCXJhZGVvbl92bV9maW5pKHJkZXYsIHZtKTsKIAkJfQogCi0JCXJhZGVvbl92bV9maW5pKHJkZXYsIHZtKTsKIAkJa2ZyZWUoZnByaXYpOwogCQlmaWxlX3ByaXYtPmRyaXZlcl9wcml2ID0gTlVMTDsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9wbS5jIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fcG0uYwppbmRleCAzMjUyMmNjLi5mN2RhOGZlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9wbS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX3BtLmMKQEAgLTEyODcsOCArMTI4NywzOSBAQAogCXJldHVybiByZXQ7CiB9CiAKK3N0cnVjdCByYWRlb25fZHBtX3F1aXJrIHsKKwl1MzIgY2hpcF92ZW5kb3I7CisJdTMyIGNoaXBfZGV2aWNlOworCXUzMiBzdWJzeXNfdmVuZG9yOworCXUzMiBzdWJzeXNfZGV2aWNlOworfTsKKworLyogY2FyZHMgd2l0aCBkcG0gc3RhYmlsaXR5IHByb2JsZW1zICovCitzdGF0aWMgc3RydWN0IHJhZGVvbl9kcG1fcXVpcmsgcmFkZW9uX2RwbV9xdWlya19saXN0W10gPSB7CisJLyogVFVSS1MgLSBodHRwczovL2J1Z3MubGF1bmNocGFkLm5ldC91YnVudHUvK3NvdXJjZS9saW51eC8rYnVnLzEzODY1MzQgKi8KKwl7IFBDSV9WRU5ET1JfSURfQVRJLCAweDY3NTksIDB4MTY4MiwgMHgzMTk1IH0sCisJLyogVFVSS1MgLSBodHRwczovL2J1Z3ppbGxhLmtlcm5lbC5vcmcvc2hvd19idWcuY2dpP2lkPTgzNzMxICovCisJeyBQQ0lfVkVORE9SX0lEX0FUSSwgMHg2ODQwLCAweDExNzksIDB4ZmI4MSB9LAorCXsgMCwgMCwgMCwgMCB9LAorfTsKKwogaW50IHJhZGVvbl9wbV9pbml0KHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2KQogeworCXN0cnVjdCByYWRlb25fZHBtX3F1aXJrICpwID0gcmFkZW9uX2RwbV9xdWlya19saXN0OworCWJvb2wgZGlzYWJsZV9kcG0gPSBmYWxzZTsKKworCS8qIEFwcGx5IGRwbSBxdWlya3MgKi8KKwl3aGlsZSAocCAmJiBwLT5jaGlwX2RldmljZSAhPSAwKSB7CisJCWlmIChyZGV2LT5wZGV2LT52ZW5kb3IgPT0gcC0+Y2hpcF92ZW5kb3IgJiYKKwkJICAgIHJkZXYtPnBkZXYtPmRldmljZSA9PSBwLT5jaGlwX2RldmljZSAmJgorCQkgICAgcmRldi0+cGRldi0+c3Vic3lzdGVtX3ZlbmRvciA9PSBwLT5zdWJzeXNfdmVuZG9yICYmCisJCSAgICByZGV2LT5wZGV2LT5zdWJzeXN0ZW1fZGV2aWNlID09IHAtPnN1YnN5c19kZXZpY2UpIHsKKwkJCWRpc2FibGVfZHBtID0gdHJ1ZTsKKwkJCWJyZWFrOworCQl9CisJCSsrcDsKKwl9CisKIAkvKiBlbmFibGUgZHBtIG9uIHJ2Nnh4KyAqLwogCXN3aXRjaCAocmRldi0+ZmFtaWx5KSB7CiAJY2FzZSBDSElQX1JWNjEwOgpAQCAtMTM0NCw2ICsxMzc1LDggQEAKIAkJCSAoIShyZGV2LT5mbGFncyAmIFJBREVPTl9JU19JR1ApKSAmJgogCQkJICghcmRldi0+c21jX2Z3KSkKIAkJCXJkZXYtPnBtLnBtX21ldGhvZCA9IFBNX01FVEhPRF9QUk9GSUxFOworCQllbHNlIGlmIChkaXNhYmxlX2RwbSAmJiAocmFkZW9uX2RwbSA9PSAtMSkpCisJCQlyZGV2LT5wbS5wbV9tZXRob2QgPSBQTV9NRVRIT0RfUFJPRklMRTsKIAkJZWxzZSBpZiAocmFkZW9uX2RwbSA9PSAwKQogCQkJcmRldi0+cG0ucG1fbWV0aG9kID0gUE1fTUVUSE9EX1BST0ZJTEU7CiAJCWVsc2UKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX3Rlc3QuYyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX3Rlc3QuYwppbmRleCAwN2I1MDZiLi43OTE4MTgxNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fdGVzdC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX3Rlc3QuYwpAQCAtMTE5LDExICsxMTksMTEgQEAKIAkJaWYgKHJpbmcgPT0gUjYwMF9SSU5HX1RZUEVfRE1BX0lOREVYKQogCQkJZmVuY2UgPSByYWRlb25fY29weV9kbWEocmRldiwgZ3R0X2FkZHIsIHZyYW1fYWRkciwKIAkJCQkJCXNpemUgLyBSQURFT05fR1BVX1BBR0VfU0laRSwKLQkJCQkJCU5VTEwpOworCQkJCQkJdnJhbV9vYmotPnRiby5yZXN2KTsKIAkJZWxzZQogCQkJZmVuY2UgPSByYWRlb25fY29weV9ibGl0KHJkZXYsIGd0dF9hZGRyLCB2cmFtX2FkZHIsCiAJCQkJCQkgc2l6ZSAvIFJBREVPTl9HUFVfUEFHRV9TSVpFLAotCQkJCQkJIE5VTEwpOworCQkJCQkJIHZyYW1fb2JqLT50Ym8ucmVzdik7CiAJCWlmIChJU19FUlIoZmVuY2UpKSB7CiAJCQlEUk1fRVJST1IoIkZhaWxlZCBHVFQtPlZSQU0gY29weSAlZFxuIiwgaSk7CiAJCQlyID0gUFRSX0VSUihmZW5jZSk7CkBAIC0xNzAsMTEgKzE3MCwxMSBAQAogCQlpZiAocmluZyA9PSBSNjAwX1JJTkdfVFlQRV9ETUFfSU5ERVgpCiAJCQlmZW5jZSA9IHJhZGVvbl9jb3B5X2RtYShyZGV2LCB2cmFtX2FkZHIsIGd0dF9hZGRyLAogCQkJCQkJc2l6ZSAvIFJBREVPTl9HUFVfUEFHRV9TSVpFLAotCQkJCQkJTlVMTCk7CisJCQkJCQl2cmFtX29iai0+dGJvLnJlc3YpOwogCQllbHNlCiAJCQlmZW5jZSA9IHJhZGVvbl9jb3B5X2JsaXQocmRldiwgdnJhbV9hZGRyLCBndHRfYWRkciwKIAkJCQkJCSBzaXplIC8gUkFERU9OX0dQVV9QQUdFX1NJWkUsCi0JCQkJCQkgTlVMTCk7CisJCQkJCQkgdnJhbV9vYmotPnRiby5yZXN2KTsKIAkJaWYgKElTX0VSUihmZW5jZSkpIHsKIAkJCURSTV9FUlJPUigiRmFpbGVkIFZSQU0tPkdUVCBjb3B5ICVkXG4iLCBpKTsKIAkJCXIgPSBQVFJfRVJSKGZlbmNlKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX3ZtLmMgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl92bS5jCmluZGV4IGNkZTQ4YzQuLjJhNWE0YTkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX3ZtLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fdm0uYwpAQCAtNTg3LDEwICs1ODcsOCBAQAogCXVpbnQ2NF90IHJlc3VsdDsKIAogCS8qIHBhZ2UgdGFibGUgb2Zmc2V0ICovCi0JcmVzdWx0ID0gcmRldi0+Z2FydC5wYWdlc19hZGRyW2FkZHIgPj4gUEFHRV9TSElGVF07Ci0KLQkvKiBpbiBjYXNlIGNwdSBwYWdlIHNpemUgIT0gZ3B1IHBhZ2Ugc2l6ZSovCi0JcmVzdWx0IHw9IGFkZHIgJiAoflBBR0VfTUFTSyk7CisJcmVzdWx0ID0gcmRldi0+Z2FydC5wYWdlc19lbnRyeVthZGRyID4+IFJBREVPTl9HUFVfUEFHRV9TSElGVF07CisJcmVzdWx0ICY9IH5SQURFT05fR1BVX1BBR0VfTUFTSzsKIAogCXJldHVybiByZXN1bHQ7CiB9CkBAIC03NDUsOSArNzQzLDExIEBACiAJICovCiAKIAkvKiBOSSBpcyBvcHRpbWl6ZWQgZm9yIDI1NktCIGZyYWdtZW50cywgU0kgYW5kIG5ld2VyIGZvciA2NEtCICovCi0JdWludDY0X3QgZnJhZ19mbGFncyA9IHJkZXYtPmZhbWlseSA9PSBDSElQX0NBWU1BTiA/CisJdWludDY0X3QgZnJhZ19mbGFncyA9ICgocmRldi0+ZmFtaWx5ID09IENISVBfQ0FZTUFOKSB8fAorCQkJICAgICAgIChyZGV2LT5mYW1pbHkgPT0gQ0hJUF9BUlVCQSkpID8KIAkJCVI2MDBfUFRFX0ZSQUdfMjU2S0IgOiBSNjAwX1BURV9GUkFHXzY0S0I7Ci0JdWludDY0X3QgZnJhZ19hbGlnbiA9IHJkZXYtPmZhbWlseSA9PSBDSElQX0NBWU1BTiA/IDB4MjAwIDogMHg4MDsKKwl1aW50NjRfdCBmcmFnX2FsaWduID0gKChyZGV2LT5mYW1pbHkgPT0gQ0hJUF9DQVlNQU4pIHx8CisJCQkgICAgICAgKHJkZXYtPmZhbWlseSA9PSBDSElQX0FSVUJBKSkgPyAweDIwMCA6IDB4ODA7CiAKIAl1aW50NjRfdCBmcmFnX3N0YXJ0ID0gQUxJR04ocGVfc3RhcnQsIGZyYWdfYWxpZ24pOwogCXVpbnQ2NF90IGZyYWdfZW5kID0gcGVfZW5kICYgfihmcmFnX2FsaWduIC0gMSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JzNDAwLmMgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JzNDAwLmMKaW5kZXggYzU3OTlmMTYuLjM0ZTMyMzUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcnM0MDAuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JzNDAwLmMKQEAgLTIxMiwxMSArMjEyLDkgQEAKICNkZWZpbmUgUlM0MDBfUFRFX1dSSVRFQUJMRSAoMSA8PCAyKQogI2RlZmluZSBSUzQwMF9QVEVfUkVBREFCTEUgICgxIDw8IDMpCiAKLXZvaWQgcnM0MDBfZ2FydF9zZXRfcGFnZShzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldiwgdW5zaWduZWQgaSwKLQkJCSB1aW50NjRfdCBhZGRyLCB1aW50MzJfdCBmbGFncykKK3VpbnQ2NF90IHJzNDAwX2dhcnRfZ2V0X3BhZ2VfZW50cnkodWludDY0X3QgYWRkciwgdWludDMyX3QgZmxhZ3MpCiB7CiAJdWludDMyX3QgZW50cnk7Ci0JdTMyICpndHQgPSByZGV2LT5nYXJ0LnB0cjsKIAogCWVudHJ5ID0gKGxvd2VyXzMyX2JpdHMoYWRkcikgJiBQQUdFX01BU0spIHwKIAkJKCh1cHBlcl8zMl9iaXRzKGFkZHIpICYgMHhmZikgPDwgNCk7CkBAIC0yMjYsOCArMjI0LDE0IEBACiAJCWVudHJ5IHw9IFJTNDAwX1BURV9XUklURUFCTEU7CiAJaWYgKCEoZmxhZ3MgJiBSQURFT05fR0FSVF9QQUdFX1NOT09QKSkKIAkJZW50cnkgfD0gUlM0MDBfUFRFX1VOU05PT1BFRDsKLQllbnRyeSA9IGNwdV90b19sZTMyKGVudHJ5KTsKLQlndHRbaV0gPSBlbnRyeTsKKwlyZXR1cm4gZW50cnk7Cit9CisKK3ZvaWQgcnM0MDBfZ2FydF9zZXRfcGFnZShzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldiwgdW5zaWduZWQgaSwKKwkJCSB1aW50NjRfdCBlbnRyeSkKK3sKKwl1MzIgKmd0dCA9IHJkZXYtPmdhcnQucHRyOworCWd0dFtpXSA9IGNwdV90b19sZTMyKGxvd2VyXzMyX2JpdHMoZW50cnkpKTsKIH0KIAogaW50IHJzNDAwX21jX3dhaXRfZm9yX2lkbGUoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JzNjAwLmMgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JzNjAwLmMKaW5kZXggOWFjYjFjMy4uNzRiY2U5MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yczYwMC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcnM2MDAuYwpAQCAtNjI1LDExICs2MjUsOCBAQAogCXJhZGVvbl9nYXJ0X3RhYmxlX3ZyYW1fZnJlZShyZGV2KTsKIH0KIAotdm9pZCByczYwMF9nYXJ0X3NldF9wYWdlKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2LCB1bnNpZ25lZCBpLAotCQkJIHVpbnQ2NF90IGFkZHIsIHVpbnQzMl90IGZsYWdzKQordWludDY0X3QgcnM2MDBfZ2FydF9nZXRfcGFnZV9lbnRyeSh1aW50NjRfdCBhZGRyLCB1aW50MzJfdCBmbGFncykKIHsKLQl2b2lkIF9faW9tZW0gKnB0ciA9ICh2b2lkICopcmRldi0+Z2FydC5wdHI7Ci0KIAlhZGRyID0gYWRkciAmIDB4RkZGRkZGRkZGRkZGRjAwMFVMTDsKIAlhZGRyIHw9IFI2MDBfUFRFX1NZU1RFTTsKIAlpZiAoZmxhZ3MgJiBSQURFT05fR0FSVF9QQUdFX1ZBTElEKQpAQCAtNjQwLDcgKzYzNywxNCBAQAogCQlhZGRyIHw9IFI2MDBfUFRFX1dSSVRFQUJMRTsKIAlpZiAoZmxhZ3MgJiBSQURFT05fR0FSVF9QQUdFX1NOT09QKQogCQlhZGRyIHw9IFI2MDBfUFRFX1NOT09QRUQ7Ci0Jd3JpdGVxKGFkZHIsIHB0ciArIChpICogOCkpOworCXJldHVybiBhZGRyOworfQorCit2b2lkIHJzNjAwX2dhcnRfc2V0X3BhZ2Uoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYsIHVuc2lnbmVkIGksCisJCQkgdWludDY0X3QgZW50cnkpCit7CisJdm9pZCBfX2lvbWVtICpwdHIgPSAodm9pZCAqKXJkZXYtPmdhcnQucHRyOworCXdyaXRlcShlbnRyeSwgcHRyICsgKGkgKiA4KSk7CiB9CiAKIGludCByczYwMF9pcnFfc2V0KHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9zaS5jIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9zaS5jCmluZGV4IDYwZGY0NDQuLjVkODliODcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vc2kuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3NpLmMKQEAgLTUwNTcsNiArNTA1NywxNiBAQAogCXJhZGVvbl9yaW5nX3dyaXRlKHJpbmcsIDApOwogCXJhZGVvbl9yaW5nX3dyaXRlKHJpbmcsIDEgPDwgdm1faWQpOwogCisJLyogd2FpdCBmb3IgdGhlIGludmFsaWRhdGUgdG8gY29tcGxldGUgKi8KKwlyYWRlb25fcmluZ193cml0ZShyaW5nLCBQQUNLRVQzKFBBQ0tFVDNfV0FJVF9SRUdfTUVNLCA1KSk7CisJcmFkZW9uX3Jpbmdfd3JpdGUocmluZywgKFdBSVRfUkVHX01FTV9GVU5DVElPTigwKSB8ICAvKiBhbHdheXMgKi8KKwkJCQkgV0FJVF9SRUdfTUVNX0VOR0lORSgwKSkpOyAvKiBtZSAqLworCXJhZGVvbl9yaW5nX3dyaXRlKHJpbmcsIFZNX0lOVkFMSURBVEVfUkVRVUVTVCA+PiAyKTsKKwlyYWRlb25fcmluZ193cml0ZShyaW5nLCAwKTsKKwlyYWRlb25fcmluZ193cml0ZShyaW5nLCAwKTsgLyogcmVmICovCisJcmFkZW9uX3Jpbmdfd3JpdGUocmluZywgMCk7IC8qIG1hc2sgKi8KKwlyYWRlb25fcmluZ193cml0ZShyaW5nLCAweDIwKTsgLyogcG9sbCBpbnRlcnZhbCAqLworCiAJLyogc3luYyBQRlAgdG8gTUUsIG90aGVyd2lzZSB3ZSBtaWdodCBnZXQgaW52YWxpZCBQRlAgcmVhZHMgKi8KIAlyYWRlb25fcmluZ193cml0ZShyaW5nLCBQQUNLRVQzKFBBQ0tFVDNfUEZQX1NZTkNfTUUsIDApKTsKIAlyYWRlb25fcmluZ193cml0ZShyaW5nLCAweDApOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9zaV9kbWEuYyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vc2lfZG1hLmMKaW5kZXggZjVjYzc3Ny4uODMyMDc5MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9zaV9kbWEuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3NpX2RtYS5jCkBAIC0xMjMsNyArMTIzLDYgQEAKIAkJZm9yICg7IG5kdyA+IDA7IG5kdyAtPSAyLCAtLWNvdW50LCBwZSArPSA4KSB7CiAJCQlpZiAoZmxhZ3MgJiBSNjAwX1BURV9TWVNURU0pIHsKIAkJCQl2YWx1ZSA9IHJhZGVvbl92bV9tYXBfZ2FydChyZGV2LCBhZGRyKTsKLQkJCQl2YWx1ZSAmPSAweEZGRkZGRkZGRkZGRkYwMDBVTEw7CiAJCQl9IGVsc2UgaWYgKGZsYWdzICYgUjYwMF9QVEVfVkFMSUQpIHsKIAkJCQl2YWx1ZSA9IGFkZHI7CiAJCQl9IGVsc2UgewpAQCAtMjA2LDYgKzIwNSwxNCBAQAogCXJhZGVvbl9yaW5nX3dyaXRlKHJpbmcsIERNQV9QQUNLRVQoRE1BX1BBQ0tFVF9TUkJNX1dSSVRFLCAwLCAwLCAwLCAwKSk7CiAJcmFkZW9uX3Jpbmdfd3JpdGUocmluZywgKDB4ZiA8PCAxNikgfCAoVk1fSU5WQUxJREFURV9SRVFVRVNUID4+IDIpKTsKIAlyYWRlb25fcmluZ193cml0ZShyaW5nLCAxIDw8IHZtX2lkKTsKKworCS8qIHdhaXQgZm9yIGludmFsaWRhdGUgdG8gY29tcGxldGUgKi8KKwlyYWRlb25fcmluZ193cml0ZShyaW5nLCBETUFfUEFDS0VUKERNQV9QQUNLRVRfUE9MTF9SRUdfTUVNLCAwLCAwLCAwLCAwKSk7CisJcmFkZW9uX3Jpbmdfd3JpdGUocmluZywgVk1fSU5WQUxJREFURV9SRVFVRVNUKTsKKwlyYWRlb25fcmluZ193cml0ZShyaW5nLCAweGZmIDw8IDE2KTsgLyogcmV0cnkgKi8KKwlyYWRlb25fcmluZ193cml0ZShyaW5nLCAxIDw8IHZtX2lkKTsgLyogbWFzayAqLworCXJhZGVvbl9yaW5nX3dyaXRlKHJpbmcsIDApOyAvKiB2YWx1ZSAqLworCXJhZGVvbl9yaW5nX3dyaXRlKHJpbmcsICgwIDw8IDI4KSB8IDB4MjApOyAvKiBmdW5jKGFsd2F5cykgfCBwb2xsIGludGVydmFsICovCiB9CiAKIC8qKgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9zaV9kcG0uYyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vc2lfZHBtLmMKaW5kZXggMzJlMzU0Yi4uZWZmOGE2NCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9zaV9kcG0uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3NpX2RwbS5jCkBAIC0yOTA4LDYgKzI5MDgsMjIgQEAKIAlyZXR1cm4gcmV0OwogfQogCitzdHJ1Y3Qgc2lfZHBtX3F1aXJrIHsKKwl1MzIgY2hpcF92ZW5kb3I7CisJdTMyIGNoaXBfZGV2aWNlOworCXUzMiBzdWJzeXNfdmVuZG9yOworCXUzMiBzdWJzeXNfZGV2aWNlOworCXUzMiBtYXhfc2NsazsKKwl1MzIgbWF4X21jbGs7Cit9OworCisvKiBjYXJkcyB3aXRoIGRwbSBzdGFiaWxpdHkgcHJvYmxlbXMgKi8KK3N0YXRpYyBzdHJ1Y3Qgc2lfZHBtX3F1aXJrIHNpX2RwbV9xdWlya19saXN0W10gPSB7CisJLyogUElUQ0FJUk4gLSBodHRwczovL2J1Z3MuZnJlZWRlc2t0b3Aub3JnL3Nob3dfYnVnLmNnaT9pZD03NjQ5MCAqLworCXsgUENJX1ZFTkRPUl9JRF9BVEksIDB4NjgxMCwgMHgxNDYyLCAweDMwMzYsIDAsIDEyMDAwMCB9LAorCXsgMCwgMCwgMCwgMCB9LAorfTsKKwogc3RhdGljIHZvaWQgc2lfYXBwbHlfc3RhdGVfYWRqdXN0X3J1bGVzKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2LAogCQkJCQlzdHJ1Y3QgcmFkZW9uX3BzICpycHMpCiB7CkBAIC0yOTE4LDcgKzI5MzQsMjIgQEAKIAl1MzIgbWNsaywgc2NsazsKIAl1MTYgdmRkYywgdmRkY2k7CiAJdTMyIG1heF9zY2xrX3ZkZGMsIG1heF9tY2xrX3ZkZGNpLCBtYXhfbWNsa192ZGRjOworCXUzMiBtYXhfc2NsayA9IDAsIG1heF9tY2xrID0gMDsKIAlpbnQgaTsKKwlzdHJ1Y3Qgc2lfZHBtX3F1aXJrICpwID0gc2lfZHBtX3F1aXJrX2xpc3Q7CisKKwkvKiBBcHBseSBkcG0gcXVpcmtzICovCisJd2hpbGUgKHAgJiYgcC0+Y2hpcF9kZXZpY2UgIT0gMCkgeworCQlpZiAocmRldi0+cGRldi0+dmVuZG9yID09IHAtPmNoaXBfdmVuZG9yICYmCisJCSAgICByZGV2LT5wZGV2LT5kZXZpY2UgPT0gcC0+Y2hpcF9kZXZpY2UgJiYKKwkJICAgIHJkZXYtPnBkZXYtPnN1YnN5c3RlbV92ZW5kb3IgPT0gcC0+c3Vic3lzX3ZlbmRvciAmJgorCQkgICAgcmRldi0+cGRldi0+c3Vic3lzdGVtX2RldmljZSA9PSBwLT5zdWJzeXNfZGV2aWNlKSB7CisJCQltYXhfc2NsayA9IHAtPm1heF9zY2xrOworCQkJbWF4X21jbGsgPSBwLT5tYXhfbWNsazsKKwkJCWJyZWFrOworCQl9CisJCSsrcDsKKwl9CiAKIAlpZiAoKHJkZXYtPnBtLmRwbS5uZXdfYWN0aXZlX2NydGNfY291bnQgPiAxKSB8fAogCSAgICBuaV9kcG1fdmJsYW5rX3Rvb19zaG9ydChyZGV2KSkKQEAgLTI5NzIsNiArMzAwMywxNCBAQAogCQkJaWYgKHBzLT5wZXJmb3JtYW5jZV9sZXZlbHNbaV0ubWNsayA+IG1heF9tY2xrX3ZkZGMpCiAJCQkJcHMtPnBlcmZvcm1hbmNlX2xldmVsc1tpXS5tY2xrID0gbWF4X21jbGtfdmRkYzsKIAkJfQorCQlpZiAobWF4X21jbGspIHsKKwkJCWlmIChwcy0+cGVyZm9ybWFuY2VfbGV2ZWxzW2ldLm1jbGsgPiBtYXhfbWNsaykKKwkJCQlwcy0+cGVyZm9ybWFuY2VfbGV2ZWxzW2ldLm1jbGsgPSBtYXhfbWNsazsKKwkJfQorCQlpZiAobWF4X3NjbGspIHsKKwkJCWlmIChwcy0+cGVyZm9ybWFuY2VfbGV2ZWxzW2ldLnNjbGsgPiBtYXhfc2NsaykKKwkJCQlwcy0+cGVyZm9ybWFuY2VfbGV2ZWxzW2ldLnNjbGsgPSBtYXhfc2NsazsKKwkJfQogCX0KIAogCS8qIFhYWCB2YWxpZGF0ZSB0aGUgbWluIGNsb2NrcyByZXF1aXJlZCBmb3IgZGlzcGxheSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9zaWQuaCBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vc2lkLmgKaW5kZXggNDA2OWJlODkuLjg0OTk5MjQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vc2lkLmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9zaWQuaApAQCAtMTYzMiw2ICsxNjMyLDIzIEBACiAjZGVmaW5lCVBBQ0tFVDNfTVBFR19JTkRFWAkJCQkweDNBCiAjZGVmaW5lCVBBQ0tFVDNfQ09QWV9EVwkJCQkJMHgzQgogI2RlZmluZQlQQUNLRVQzX1dBSVRfUkVHX01FTQkJCQkweDNDCisjZGVmaW5lCQlXQUlUX1JFR19NRU1fRlVOQ1RJT04oeCkgICAgICAgICAgICAgICAgKCh4KSA8PCAwKQorICAgICAgICAgICAgICAgIC8qIDAgLSBhbHdheXMKKwkJICogMSAtIDwKKwkJICogMiAtIDw9CisJCSAqIDMgLSA9PQorCQkgKiA0IC0gIT0KKwkJICogNSAtID49CisJCSAqIDYgLSA+CisJCSAqLworI2RlZmluZQkJV0FJVF9SRUdfTUVNX01FTV9TUEFDRSh4KSAgICAgICAgICAgICAgICgoeCkgPDwgNCkKKyAgICAgICAgICAgICAgICAvKiAwIC0gcmVnCisJCSAqIDEgLSBtZW0KKwkJICovCisjZGVmaW5lCQlXQUlUX1JFR19NRU1fRU5HSU5FKHgpICAgICAgICAgICAgICAgICAgKCh4KSA8PCA4KQorICAgICAgICAgICAgICAgIC8qIDAgLSBtZQorCQkgKiAxIC0gcGZwCisJCSAqLwogI2RlZmluZQlQQUNLRVQzX01FTV9XUklURQkJCQkweDNECiAjZGVmaW5lCVBBQ0tFVDNfQ09QWV9EQVRBCQkJCTB4NDAKICNkZWZpbmUJUEFDS0VUM19DUF9ETUEJCQkJCTB4NDEKQEAgLTE4MzUsNiArMTg1Miw3IEBACiAjZGVmaW5lCURNQV9QQUNLRVRfVFJBUAkJCQkJICAweDcKICNkZWZpbmUJRE1BX1BBQ0tFVF9TUkJNX1dSSVRFCQkJCSAgMHg5CiAjZGVmaW5lCURNQV9QQUNLRVRfQ09OU1RBTlRfRklMTAkJCSAgMHhkCisjZGVmaW5lCURNQV9QQUNLRVRfUE9MTF9SRUdfTUVNCQkJCSAgMHhlCiAjZGVmaW5lCURNQV9QQUNLRVRfTk9QCQkJCQkgIDB4ZgogCiAjZGVmaW5lIFZDRV9TVEFUVVMJCQkJCTB4MjAwMDQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS92bXdnZngvdm13Z2Z4X2Rydi5jIGIvZHJpdmVycy9ncHUvZHJtL3Ztd2dmeC92bXdnZnhfZHJ2LmMKaW5kZXggN2I1ZDIyMS4uNmM2YjY1NSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3Ztd2dmeC92bXdnZnhfZHJ2LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL3Ztd2dmeC92bXdnZnhfZHJ2LmMKQEAgLTQwNiwxMSArNDA2LDkgQEAKIAkJaWYgKHVubGlrZWx5KHJldCAhPSAwKSkKIAkJCS0tZGV2X3ByaXYtPm51bV8zZF9yZXNvdXJjZXM7CiAJfSBlbHNlIGlmICh1bmhpZGVfc3ZnYSkgewotCQltdXRleF9sb2NrKCZkZXZfcHJpdi0+aHdfbXV0ZXgpOwogCQl2bXdfd3JpdGUoZGV2X3ByaXYsIFNWR0FfUkVHX0VOQUJMRSwKIAkJCSAgdm13X3JlYWQoZGV2X3ByaXYsIFNWR0FfUkVHX0VOQUJMRSkgJgogCQkJICB+U1ZHQV9SRUdfRU5BQkxFX0hJREUpOwotCQltdXRleF91bmxvY2soJmRldl9wcml2LT5od19tdXRleCk7CiAJfQogCiAJbXV0ZXhfdW5sb2NrKCZkZXZfcHJpdi0+cmVsZWFzZV9tdXRleCk7CkBAIC00MzMsMTMgKzQzMSwxMCBAQAogCW11dGV4X2xvY2soJmRldl9wcml2LT5yZWxlYXNlX211dGV4KTsKIAlpZiAodW5saWtlbHkoLS1kZXZfcHJpdi0+bnVtXzNkX3Jlc291cmNlcyA9PSAwKSkKIAkJdm13X3JlbGVhc2VfZGV2aWNlKGRldl9wcml2KTsKLQllbHNlIGlmIChoaWRlX3N2Z2EpIHsKLQkJbXV0ZXhfbG9jaygmZGV2X3ByaXYtPmh3X211dGV4KTsKKwllbHNlIGlmIChoaWRlX3N2Z2EpCiAJCXZtd193cml0ZShkZXZfcHJpdiwgU1ZHQV9SRUdfRU5BQkxFLAogCQkJICB2bXdfcmVhZChkZXZfcHJpdiwgU1ZHQV9SRUdfRU5BQkxFKSB8CiAJCQkgIFNWR0FfUkVHX0VOQUJMRV9ISURFKTsKLQkJbXV0ZXhfdW5sb2NrKCZkZXZfcHJpdi0+aHdfbXV0ZXgpOwotCX0KIAogCW4zZCA9IChpbnQzMl90KSBkZXZfcHJpdi0+bnVtXzNkX3Jlc291cmNlczsKIAltdXRleF91bmxvY2soJmRldl9wcml2LT5yZWxlYXNlX211dGV4KTsKQEAgLTYwMCwxMiArNTk1LDE0IEBACiAJZGV2X3ByaXYtPmRldiA9IGRldjsKIAlkZXZfcHJpdi0+dm13X2NoaXBzZXQgPSBjaGlwc2V0OwogCWRldl9wcml2LT5sYXN0X3JlYWRfc2Vxbm8gPSAodWludDMyX3QpIC0xMDA7Ci0JbXV0ZXhfaW5pdCgmZGV2X3ByaXYtPmh3X211dGV4KTsKIAltdXRleF9pbml0KCZkZXZfcHJpdi0+Y21kYnVmX211dGV4KTsKIAltdXRleF9pbml0KCZkZXZfcHJpdi0+cmVsZWFzZV9tdXRleCk7CiAJbXV0ZXhfaW5pdCgmZGV2X3ByaXYtPmJpbmRpbmdfbXV0ZXgpOwogCXJ3bG9ja19pbml0KCZkZXZfcHJpdi0+cmVzb3VyY2VfbG9jayk7CiAJdHRtX2xvY2tfaW5pdCgmZGV2X3ByaXYtPnJlc2VydmF0aW9uX3NlbSk7CisJc3Bpbl9sb2NrX2luaXQoJmRldl9wcml2LT5od19sb2NrKTsKKwlzcGluX2xvY2tfaW5pdCgmZGV2X3ByaXYtPndhaXRlcl9sb2NrKTsKKwlzcGluX2xvY2tfaW5pdCgmZGV2X3ByaXYtPmNhcF9sb2NrKTsKIAogCWZvciAoaSA9IHZtd19yZXNfY29udGV4dDsgaSA8IHZtd19yZXNfbWF4OyArK2kpIHsKIAkJaWRyX2luaXQoJmRldl9wcml2LT5yZXNfaWRyW2ldKTsKQEAgLTYyNiwxNCArNjIzLDExIEBACiAKIAlkZXZfcHJpdi0+ZW5hYmxlX2ZiID0gZW5hYmxlX2ZiZGV2OwogCi0JbXV0ZXhfbG9jaygmZGV2X3ByaXYtPmh3X211dGV4KTsKLQogCXZtd193cml0ZShkZXZfcHJpdiwgU1ZHQV9SRUdfSUQsIFNWR0FfSURfMik7CiAJc3ZnYV9pZCA9IHZtd19yZWFkKGRldl9wcml2LCBTVkdBX1JFR19JRCk7CiAJaWYgKHN2Z2FfaWQgIT0gU1ZHQV9JRF8yKSB7CiAJCXJldCA9IC1FTk9TWVM7CiAJCURSTV9FUlJPUigiVW5zdXBwb3J0ZWQgU1ZHQSBJRCAweCV4XG4iLCBzdmdhX2lkKTsKLQkJbXV0ZXhfdW5sb2NrKCZkZXZfcHJpdi0+aHdfbXV0ZXgpOwogCQlnb3RvIG91dF9lcnIwOwogCX0KIApAQCAtNjgzLDEwICs2NzcsOCBAQAogCQlkZXZfcHJpdi0+cHJpbV9iYl9tZW0gPSBkZXZfcHJpdi0+dnJhbV9zaXplOwogCiAJcmV0ID0gdm13X2RtYV9tYXNrcyhkZXZfcHJpdik7Ci0JaWYgKHVubGlrZWx5KHJldCAhPSAwKSkgewotCQltdXRleF91bmxvY2soJmRldl9wcml2LT5od19tdXRleCk7CisJaWYgKHVubGlrZWx5KHJldCAhPSAwKSkKIAkJZ290byBvdXRfZXJyMDsKLQl9CiAKIAkvKgogCSAqIExpbWl0IGJhY2sgYnVmZmVyIHNpemUgdG8gVlJBTSBzaXplLiAgUmVtb3ZlIHRoaXMgb25jZQpAQCAtNjk1LDggKzY4Nyw2IEBACiAJaWYgKGRldl9wcml2LT5wcmltX2JiX21lbSA+IGRldl9wcml2LT52cmFtX3NpemUpCiAJCWRldl9wcml2LT5wcmltX2JiX21lbSA9IGRldl9wcml2LT52cmFtX3NpemU7CiAKLQltdXRleF91bmxvY2soJmRldl9wcml2LT5od19tdXRleCk7Ci0KIAl2bXdfcHJpbnRfY2FwYWJpbGl0aWVzKGRldl9wcml2LT5jYXBhYmlsaXRpZXMpOwogCiAJaWYgKGRldl9wcml2LT5jYXBhYmlsaXRpZXMgJiBTVkdBX0NBUF9HTVIyKSB7CkBAIC0xMTYwLDkgKzExNTAsNyBAQAogCQlpZiAodW5saWtlbHkocmV0ICE9IDApKQogCQkJcmV0dXJuIHJldDsKIAkJdm13X2ttc19zYXZlX3ZnYShkZXZfcHJpdik7Ci0JCW11dGV4X2xvY2soJmRldl9wcml2LT5od19tdXRleCk7CiAJCXZtd193cml0ZShkZXZfcHJpdiwgU1ZHQV9SRUdfVFJBQ0VTLCAwKTsKLQkJbXV0ZXhfdW5sb2NrKCZkZXZfcHJpdi0+aHdfbXV0ZXgpOwogCX0KIAogCWlmIChhY3RpdmUpIHsKQEAgLTExOTYsOSArMTE4NCw3IEBACiAJaWYgKCFkZXZfcHJpdi0+ZW5hYmxlX2ZiKSB7CiAJCXZtd19rbXNfcmVzdG9yZV92Z2EoZGV2X3ByaXYpOwogCQl2bXdfM2RfcmVzb3VyY2VfZGVjKGRldl9wcml2LCB0cnVlKTsKLQkJbXV0ZXhfbG9jaygmZGV2X3ByaXYtPmh3X211dGV4KTsKIAkJdm13X3dyaXRlKGRldl9wcml2LCBTVkdBX1JFR19UUkFDRVMsIDEpOwotCQltdXRleF91bmxvY2soJmRldl9wcml2LT5od19tdXRleCk7CiAJfQogCXJldHVybiByZXQ7CiB9CkBAIC0xMjMzLDkgKzEyMTksNyBAQAogCQkJRFJNX0VSUk9SKCJVbmFibGUgdG8gY2xlYW4gVlJBTSBvbiBtYXN0ZXIgZHJvcC5cbiIpOwogCQl2bXdfa21zX3Jlc3RvcmVfdmdhKGRldl9wcml2KTsKIAkJdm13XzNkX3Jlc291cmNlX2RlYyhkZXZfcHJpdiwgdHJ1ZSk7Ci0JCW11dGV4X2xvY2soJmRldl9wcml2LT5od19tdXRleCk7CiAJCXZtd193cml0ZShkZXZfcHJpdiwgU1ZHQV9SRUdfVFJBQ0VTLCAxKTsKLQkJbXV0ZXhfdW5sb2NrKCZkZXZfcHJpdi0+aHdfbXV0ZXgpOwogCX0KIAogCWRldl9wcml2LT5hY3RpdmVfbWFzdGVyID0gJmRldl9wcml2LT5mYmRldl9tYXN0ZXI7CkBAIC0xMzY3LDEwICsxMzUxLDggQEAKIAlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gcGNpX2dldF9kcnZkYXRhKHBkZXYpOwogCXN0cnVjdCB2bXdfcHJpdmF0ZSAqZGV2X3ByaXYgPSB2bXdfcHJpdihkZXYpOwogCi0JbXV0ZXhfbG9jaygmZGV2X3ByaXYtPmh3X211dGV4KTsKIAl2bXdfd3JpdGUoZGV2X3ByaXYsIFNWR0FfUkVHX0lELCBTVkdBX0lEXzIpOwogCSh2b2lkKSB2bXdfcmVhZChkZXZfcHJpdiwgU1ZHQV9SRUdfSUQpOwotCW11dGV4X3VubG9jaygmZGV2X3ByaXYtPmh3X211dGV4KTsKIAogCS8qKgogCSAqIFJlY2xhaW0gM2QgcmVmZXJlbmNlIGhlbGQgYnkgZmJkZXYgYW5kIHBvdGVudGlhbGx5CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vdm13Z2Z4L3Ztd2dmeF9kcnYuaCBiL2RyaXZlcnMvZ3B1L2RybS92bXdnZngvdm13Z2Z4X2Rydi5oCmluZGV4IDRlZTc5OWIuLmQyNmE2ZGEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS92bXdnZngvdm13Z2Z4X2Rydi5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS92bXdnZngvdm13Z2Z4X2Rydi5oCkBAIC0zOTksNyArMzk5LDggQEAKIAl1aW50MzJfdCBtZW1vcnlfc2l6ZTsKIAlib29sIGhhc19nbXI7CiAJYm9vbCBoYXNfbW9iOwotCXN0cnVjdCBtdXRleCBod19tdXRleDsKKwlzcGlubG9ja190IGh3X2xvY2s7CisJc3BpbmxvY2tfdCBjYXBfbG9jazsKIAogCS8qCiAJICogVkdBIHJlZ2lzdGVycy4KQEAgLTQ0OSw4ICs0NTAsOSBAQAogCWF0b21pY190IG1hcmtlcl9zZXE7CiAJd2FpdF9xdWV1ZV9oZWFkX3QgZmVuY2VfcXVldWU7CiAJd2FpdF9xdWV1ZV9oZWFkX3QgZmlmb19xdWV1ZTsKLQlpbnQgZmVuY2VfcXVldWVfd2FpdGVyczsgLyogUHJvdGVjdGVkIGJ5IGh3X211dGV4ICovCi0JaW50IGdvYWxfcXVldWVfd2FpdGVyczsgLyogUHJvdGVjdGVkIGJ5IGh3X211dGV4ICovCisJc3BpbmxvY2tfdCB3YWl0ZXJfbG9jazsKKwlpbnQgZmVuY2VfcXVldWVfd2FpdGVyczsgLyogUHJvdGVjdGVkIGJ5IHdhaXRlcl9sb2NrICovCisJaW50IGdvYWxfcXVldWVfd2FpdGVyczsgLyogUHJvdGVjdGVkIGJ5IHdhaXRlcl9sb2NrICovCiAJYXRvbWljX3QgZmlmb19xdWV1ZV93YWl0ZXJzOwogCXVpbnQzMl90IGxhc3RfcmVhZF9zZXFubzsKIAlzcGlubG9ja190IGlycV9sb2NrOwpAQCAtNTUzLDIwICs1NTUsMzUgQEAKIAlyZXR1cm4gKHN0cnVjdCB2bXdfbWFzdGVyICopIG1hc3Rlci0+ZHJpdmVyX3ByaXY7CiB9CiAKKy8qCisgKiBUaGUgbG9ja2luZyBoZXJlIGlzIGZpbmUtZ3JhaW5lZCwgc28gdGhhdCBpdCBpcyBwZXJmb3JtZWQgb25jZQorICogZm9yIGV2ZXJ5IHJlYWQtIGFuZCB3cml0ZSBvcGVyYXRpb24uIFRoaXMgaXMgb2YgY291cnNlIGNvc3RseSwgYnV0IHdlCisgKiBkb24ndCBwZXJmb3JtIG11Y2ggcmVnaXN0ZXIgYWNjZXNzIGluIHRoZSB0aW1pbmcgY3JpdGljYWwgcGF0aHMgYW55d2F5LgorICogSW5zdGVhZCB3ZSBoYXZlIHRoZSBleHRyYSBiZW5lZml0IG9mIGJlaW5nIHN1cmUgdGhhdCB3ZSBkb24ndCBmb3JnZXQKKyAqIHRoZSBodyBsb2NrIGFyb3VuZCByZWdpc3RlciBhY2Nlc3Nlcy4KKyAqLwogc3RhdGljIGlubGluZSB2b2lkIHZtd193cml0ZShzdHJ1Y3Qgdm13X3ByaXZhdGUgKmRldl9wcml2LAogCQkJICAgICB1bnNpZ25lZCBpbnQgb2Zmc2V0LCB1aW50MzJfdCB2YWx1ZSkKIHsKKwl1bnNpZ25lZCBsb25nIGlycV9mbGFnczsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZkZXZfcHJpdi0+aHdfbG9jaywgaXJxX2ZsYWdzKTsKIAlvdXRsKG9mZnNldCwgZGV2X3ByaXYtPmlvX3N0YXJ0ICsgVk1XR0ZYX0lOREVYX1BPUlQpOwogCW91dGwodmFsdWUsIGRldl9wcml2LT5pb19zdGFydCArIFZNV0dGWF9WQUxVRV9QT1JUKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZkZXZfcHJpdi0+aHdfbG9jaywgaXJxX2ZsYWdzKTsKIH0KIAogc3RhdGljIGlubGluZSB1aW50MzJfdCB2bXdfcmVhZChzdHJ1Y3Qgdm13X3ByaXZhdGUgKmRldl9wcml2LAogCQkJCXVuc2lnbmVkIGludCBvZmZzZXQpCiB7Ci0JdWludDMyX3QgdmFsOworCXVuc2lnbmVkIGxvbmcgaXJxX2ZsYWdzOworCXUzMiB2YWw7CiAKKwlzcGluX2xvY2tfaXJxc2F2ZSgmZGV2X3ByaXYtPmh3X2xvY2ssIGlycV9mbGFncyk7CiAJb3V0bChvZmZzZXQsIGRldl9wcml2LT5pb19zdGFydCArIFZNV0dGWF9JTkRFWF9QT1JUKTsKIAl2YWwgPSBpbmwoZGV2X3ByaXYtPmlvX3N0YXJ0ICsgVk1XR0ZYX1ZBTFVFX1BPUlQpOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmRldl9wcml2LT5od19sb2NrLCBpcnFfZmxhZ3MpOworCiAJcmV0dXJuIHZhbDsKIH0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3Ztd2dmeC92bXdnZnhfZmVuY2UuYyBiL2RyaXZlcnMvZ3B1L2RybS92bXdnZngvdm13Z2Z4X2ZlbmNlLmMKaW5kZXggYjc1OTRjYi4uOTQ1ZjFlMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3Ztd2dmeC92bXdnZnhfZmVuY2UuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vdm13Z2Z4L3Ztd2dmeF9mZW5jZS5jCkBAIC0zNSw3ICszNSw3IEBACiAJc3RydWN0IHZtd19wcml2YXRlICpkZXZfcHJpdjsKIAlzcGlubG9ja190IGxvY2s7CiAJc3RydWN0IGxpc3RfaGVhZCBmZW5jZV9saXN0OwotCXN0cnVjdCB3b3JrX3N0cnVjdCB3b3JrLCBwaW5nX3dvcms7CisJc3RydWN0IHdvcmtfc3RydWN0IHdvcms7CiAJdTMyIHVzZXJfZmVuY2Vfc2l6ZTsKIAl1MzIgZmVuY2Vfc2l6ZTsKIAl1MzIgZXZlbnRfZmVuY2VfYWN0aW9uX3NpemU7CkBAIC0xMzQsMTQgKzEzNCw2IEBACiAJcmV0dXJuICJzdmdhIjsKIH0KIAotc3RhdGljIHZvaWQgdm13X2ZlbmNlX3BpbmdfZnVuYyhzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCi17Ci0Jc3RydWN0IHZtd19mZW5jZV9tYW5hZ2VyICpmbWFuID0KLQkJY29udGFpbmVyX29mKHdvcmssIHN0cnVjdCB2bXdfZmVuY2VfbWFuYWdlciwgcGluZ193b3JrKTsKLQotCXZtd19maWZvX3BpbmdfaG9zdChmbWFuLT5kZXZfcHJpdiwgU1ZHQV9TWU5DX0dFTkVSSUMpOwotfQotCiBzdGF0aWMgYm9vbCB2bXdfZmVuY2VfZW5hYmxlX3NpZ25hbGluZyhzdHJ1Y3QgZmVuY2UgKmYpCiB7CiAJc3RydWN0IHZtd19mZW5jZV9vYmogKmZlbmNlID0KQEAgLTE1NSwxMSArMTQ3LDcgQEAKIAlpZiAoc2Vxbm8gLSBmZW5jZS0+YmFzZS5zZXFubyA8IFZNV19GRU5DRV9XUkFQKQogCQlyZXR1cm4gZmFsc2U7CiAKLQlpZiAobXV0ZXhfdHJ5bG9jaygmZGV2X3ByaXYtPmh3X211dGV4KSkgewotCQl2bXdfZmlmb19waW5nX2hvc3RfbG9ja2VkKGRldl9wcml2LCBTVkdBX1NZTkNfR0VORVJJQyk7Ci0JCW11dGV4X3VubG9jaygmZGV2X3ByaXYtPmh3X211dGV4KTsKLQl9IGVsc2UKLQkJc2NoZWR1bGVfd29yaygmZm1hbi0+cGluZ193b3JrKTsKKwl2bXdfZmlmb19waW5nX2hvc3QoZGV2X3ByaXYsIFNWR0FfU1lOQ19HRU5FUklDKTsKIAogCXJldHVybiB0cnVlOwogfQpAQCAtMzA1LDcgKzI5Myw2IEBACiAJSU5JVF9MSVNUX0hFQUQoJmZtYW4tPmZlbmNlX2xpc3QpOwogCUlOSVRfTElTVF9IRUFEKCZmbWFuLT5jbGVhbnVwX2xpc3QpOwogCUlOSVRfV09SSygmZm1hbi0+d29yaywgJnZtd19mZW5jZV93b3JrX2Z1bmMpOwotCUlOSVRfV09SSygmZm1hbi0+cGluZ193b3JrLCAmdm13X2ZlbmNlX3BpbmdfZnVuYyk7CiAJZm1hbi0+Zmlmb19kb3duID0gdHJ1ZTsKIAlmbWFuLT51c2VyX2ZlbmNlX3NpemUgPSB0dG1fcm91bmRfcG90KHNpemVvZihzdHJ1Y3Qgdm13X3VzZXJfZmVuY2UpKTsKIAlmbWFuLT5mZW5jZV9zaXplID0gdHRtX3JvdW5kX3BvdChzaXplb2Yoc3RydWN0IHZtd19mZW5jZV9vYmopKTsKQEAgLTMyMyw3ICszMTAsNiBAQAogCWJvb2wgbGlzdHNfZW1wdHk7CiAKIAkodm9pZCkgY2FuY2VsX3dvcmtfc3luYygmZm1hbi0+d29yayk7Ci0JKHZvaWQpIGNhbmNlbF93b3JrX3N5bmMoJmZtYW4tPnBpbmdfd29yayk7CiAKIAlzcGluX2xvY2tfaXJxc2F2ZSgmZm1hbi0+bG9jaywgaXJxX2ZsYWdzKTsKIAlsaXN0c19lbXB0eSA9IGxpc3RfZW1wdHkoJmZtYW4tPmZlbmNlX2xpc3QpICYmCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vdm13Z2Z4L3Ztd2dmeF9maWZvLmMgYi9kcml2ZXJzL2dwdS9kcm0vdm13Z2Z4L3Ztd2dmeF9maWZvLmMKaW5kZXggMDllMTBhZS4uMzlmMmIwMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3Ztd2dmeC92bXdnZnhfZmlmby5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS92bXdnZngvdm13Z2Z4X2ZpZm8uYwpAQCAtNDQsMTAgKzQ0LDEwIEBACiAJCWlmICghZGV2X3ByaXYtPmhhc19tb2IpCiAJCQlyZXR1cm4gZmFsc2U7CiAKLQkJbXV0ZXhfbG9jaygmZGV2X3ByaXYtPmh3X211dGV4KTsKKwkJc3Bpbl9sb2NrKCZkZXZfcHJpdi0+Y2FwX2xvY2spOwogCQl2bXdfd3JpdGUoZGV2X3ByaXYsIFNWR0FfUkVHX0RFVl9DQVAsIFNWR0EzRF9ERVZDQVBfM0QpOwogCQlyZXN1bHQgPSB2bXdfcmVhZChkZXZfcHJpdiwgU1ZHQV9SRUdfREVWX0NBUCk7Ci0JCW11dGV4X3VubG9jaygmZGV2X3ByaXYtPmh3X211dGV4KTsKKwkJc3Bpbl91bmxvY2soJmRldl9wcml2LT5jYXBfbG9jayk7CiAKIAkJcmV0dXJuIChyZXN1bHQgIT0gMCk7CiAJfQpAQCAtMTIwLDcgKzEyMCw2IEBACiAJRFJNX0lORk8oImhlaWdodCAlZFxuIiwgdm13X3JlYWQoZGV2X3ByaXYsIFNWR0FfUkVHX0hFSUdIVCkpOwogCURSTV9JTkZPKCJicHAgJWRcbiIsIHZtd19yZWFkKGRldl9wcml2LCBTVkdBX1JFR19CSVRTX1BFUl9QSVhFTCkpOwogCi0JbXV0ZXhfbG9jaygmZGV2X3ByaXYtPmh3X211dGV4KTsKIAlkZXZfcHJpdi0+ZW5hYmxlX3N0YXRlID0gdm13X3JlYWQoZGV2X3ByaXYsIFNWR0FfUkVHX0VOQUJMRSk7CiAJZGV2X3ByaXYtPmNvbmZpZ19kb25lX3N0YXRlID0gdm13X3JlYWQoZGV2X3ByaXYsIFNWR0FfUkVHX0NPTkZJR19ET05FKTsKIAlkZXZfcHJpdi0+dHJhY2VzX3N0YXRlID0gdm13X3JlYWQoZGV2X3ByaXYsIFNWR0FfUkVHX1RSQUNFUyk7CkBAIC0xNDMsNyArMTQyLDYgQEAKIAltYigpOwogCiAJdm13X3dyaXRlKGRldl9wcml2LCBTVkdBX1JFR19DT05GSUdfRE9ORSwgMSk7Ci0JbXV0ZXhfdW5sb2NrKCZkZXZfcHJpdi0+aHdfbXV0ZXgpOwogCiAJbWF4ID0gaW9yZWFkMzIoZmlmb19tZW0gKyBTVkdBX0ZJRk9fTUFYKTsKIAltaW4gPSBpb3JlYWQzMihmaWZvX21lbSAgKyBTVkdBX0ZJRk9fTUlOKTsKQEAgLTE2MCwzMSArMTU4LDI4IEBACiAJcmV0dXJuIHZtd19maWZvX3NlbmRfZmVuY2UoZGV2X3ByaXYsICZkdW1teSk7CiB9CiAKLXZvaWQgdm13X2ZpZm9fcGluZ19ob3N0X2xvY2tlZChzdHJ1Y3Qgdm13X3ByaXZhdGUgKmRldl9wcml2LCB1aW50MzJfdCByZWFzb24pCit2b2lkIHZtd19maWZvX3BpbmdfaG9zdChzdHJ1Y3Qgdm13X3ByaXZhdGUgKmRldl9wcml2LCB1aW50MzJfdCByZWFzb24pCiB7CiAJX19sZTMyIF9faW9tZW0gKmZpZm9fbWVtID0gZGV2X3ByaXYtPm1taW9fdmlydDsKKwlzdGF0aWMgREVGSU5FX1NQSU5MT0NLKHBpbmdfbG9jayk7CisJdW5zaWduZWQgbG9uZyBpcnFfZmxhZ3M7CiAKKwkvKgorCSAqIFRoZSBwaW5nX2xvY2sgaXMgbmVlZGVkIGJlY2F1c2Ugd2UgZG9uJ3QgaGF2ZSBhbiBhdG9taWMKKwkgKiB0ZXN0LWFuZC1zZXQgb2YgdGhlIFNWR0FfRklGT19CVVNZIHJlZ2lzdGVyLgorCSAqLworCXNwaW5fbG9ja19pcnFzYXZlKCZwaW5nX2xvY2ssIGlycV9mbGFncyk7CiAJaWYgKHVubGlrZWx5KGlvcmVhZDMyKGZpZm9fbWVtICsgU1ZHQV9GSUZPX0JVU1kpID09IDApKSB7CiAJCWlvd3JpdGUzMigxLCBmaWZvX21lbSArIFNWR0FfRklGT19CVVNZKTsKIAkJdm13X3dyaXRlKGRldl9wcml2LCBTVkdBX1JFR19TWU5DLCByZWFzb24pOwogCX0KLX0KLQotdm9pZCB2bXdfZmlmb19waW5nX2hvc3Qoc3RydWN0IHZtd19wcml2YXRlICpkZXZfcHJpdiwgdWludDMyX3QgcmVhc29uKQotewotCW11dGV4X2xvY2soJmRldl9wcml2LT5od19tdXRleCk7Ci0KLQl2bXdfZmlmb19waW5nX2hvc3RfbG9ja2VkKGRldl9wcml2LCByZWFzb24pOwotCi0JbXV0ZXhfdW5sb2NrKCZkZXZfcHJpdi0+aHdfbXV0ZXgpOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnBpbmdfbG9jaywgaXJxX2ZsYWdzKTsKIH0KIAogdm9pZCB2bXdfZmlmb19yZWxlYXNlKHN0cnVjdCB2bXdfcHJpdmF0ZSAqZGV2X3ByaXYsIHN0cnVjdCB2bXdfZmlmb19zdGF0ZSAqZmlmbykKIHsKIAlfX2xlMzIgX19pb21lbSAqZmlmb19tZW0gPSBkZXZfcHJpdi0+bW1pb192aXJ0OwogCi0JbXV0ZXhfbG9jaygmZGV2X3ByaXYtPmh3X211dGV4KTsKLQogCXZtd193cml0ZShkZXZfcHJpdiwgU1ZHQV9SRUdfU1lOQywgU1ZHQV9TWU5DX0dFTkVSSUMpOwogCXdoaWxlICh2bXdfcmVhZChkZXZfcHJpdiwgU1ZHQV9SRUdfQlVTWSkgIT0gMCkKIAkJOwpAQCAtMTk4LDcgKzE5Myw2IEBACiAJdm13X3dyaXRlKGRldl9wcml2LCBTVkdBX1JFR19UUkFDRVMsCiAJCSAgZGV2X3ByaXYtPnRyYWNlc19zdGF0ZSk7CiAKLQltdXRleF91bmxvY2soJmRldl9wcml2LT5od19tdXRleCk7CiAJdm13X21hcmtlcl9xdWV1ZV90YWtlZG93bigmZmlmby0+bWFya2VyX3F1ZXVlKTsKIAogCWlmIChsaWtlbHkoZmlmby0+c3RhdGljX2J1ZmZlciAhPSBOVUxMKSkgewpAQCAtMjcxLDcgKzI2NSw3IEBACiAJCXJldHVybiB2bXdfZmlmb193YWl0X25vaXJxKGRldl9wcml2LCBieXRlcywKIAkJCQkJICAgaW50ZXJydXB0aWJsZSwgdGltZW91dCk7CiAKLQltdXRleF9sb2NrKCZkZXZfcHJpdi0+aHdfbXV0ZXgpOworCXNwaW5fbG9jaygmZGV2X3ByaXYtPndhaXRlcl9sb2NrKTsKIAlpZiAoYXRvbWljX2FkZF9yZXR1cm4oMSwgJmRldl9wcml2LT5maWZvX3F1ZXVlX3dhaXRlcnMpID4gMCkgewogCQlzcGluX2xvY2tfaXJxc2F2ZSgmZGV2X3ByaXYtPmlycV9sb2NrLCBpcnFfZmxhZ3MpOwogCQlvdXRsKFNWR0FfSVJRRkxBR19GSUZPX1BST0dSRVNTLApAQCAtMjgwLDcgKzI3NCw3IEBACiAJCXZtd193cml0ZShkZXZfcHJpdiwgU1ZHQV9SRUdfSVJRTUFTSywgZGV2X3ByaXYtPmlycV9tYXNrKTsKIAkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZGV2X3ByaXYtPmlycV9sb2NrLCBpcnFfZmxhZ3MpOwogCX0KLQltdXRleF91bmxvY2soJmRldl9wcml2LT5od19tdXRleCk7CisJc3Bpbl91bmxvY2soJmRldl9wcml2LT53YWl0ZXJfbG9jayk7CiAKIAlpZiAoaW50ZXJydXB0aWJsZSkKIAkJcmV0ID0gd2FpdF9ldmVudF9pbnRlcnJ1cHRpYmxlX3RpbWVvdXQKQEAgLTI5NiwxNCArMjkwLDE0IEBACiAJZWxzZSBpZiAobGlrZWx5KHJldCA+IDApKQogCQlyZXQgPSAwOwogCi0JbXV0ZXhfbG9jaygmZGV2X3ByaXYtPmh3X211dGV4KTsKKwlzcGluX2xvY2soJmRldl9wcml2LT53YWl0ZXJfbG9jayk7CiAJaWYgKGF0b21pY19kZWNfYW5kX3Rlc3QoJmRldl9wcml2LT5maWZvX3F1ZXVlX3dhaXRlcnMpKSB7CiAJCXNwaW5fbG9ja19pcnFzYXZlKCZkZXZfcHJpdi0+aXJxX2xvY2ssIGlycV9mbGFncyk7CiAJCWRldl9wcml2LT5pcnFfbWFzayAmPSB+U1ZHQV9JUlFGTEFHX0ZJRk9fUFJPR1JFU1M7CiAJCXZtd193cml0ZShkZXZfcHJpdiwgU1ZHQV9SRUdfSVJRTUFTSywgZGV2X3ByaXYtPmlycV9tYXNrKTsKIAkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZGV2X3ByaXYtPmlycV9sb2NrLCBpcnFfZmxhZ3MpOwogCX0KLQltdXRleF91bmxvY2soJmRldl9wcml2LT5od19tdXRleCk7CisJc3Bpbl91bmxvY2soJmRldl9wcml2LT53YWl0ZXJfbG9jayk7CiAKIAlyZXR1cm4gcmV0OwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3Ztd2dmeC92bXdnZnhfaW9jdGwuYyBiL2RyaXZlcnMvZ3B1L2RybS92bXdnZngvdm13Z2Z4X2lvY3RsLmMKaW5kZXggMzc4ODFlYy4uNjljOGNlMjMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS92bXdnZngvdm13Z2Z4X2lvY3RsLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL3Ztd2dmeC92bXdnZnhfaW9jdGwuYwpAQCAtMTM1LDEzICsxMzUsMTMgQEAKIAkJKHBhaXJfb2Zmc2V0ICsgbWF4X3NpemUgKiBzaXplb2YoU1ZHQTNkQ2FwUGFpcikpIC8gc2l6ZW9mKHUzMik7CiAJY29tcGF0X2NhcC0+aGVhZGVyLnR5cGUgPSBTVkdBM0RDQVBTX1JFQ09SRF9ERVZDQVBTOwogCi0JbXV0ZXhfbG9jaygmZGV2X3ByaXYtPmh3X211dGV4KTsKKwlzcGluX2xvY2soJmRldl9wcml2LT5jYXBfbG9jayk7CiAJZm9yIChpID0gMDsgaSA8IG1heF9zaXplOyArK2kpIHsKIAkJdm13X3dyaXRlKGRldl9wcml2LCBTVkdBX1JFR19ERVZfQ0FQLCBpKTsKIAkJY29tcGF0X2NhcC0+cGFpcnNbaV1bMF0gPSBpOwogCQljb21wYXRfY2FwLT5wYWlyc1tpXVsxXSA9IHZtd19yZWFkKGRldl9wcml2LCBTVkdBX1JFR19ERVZfQ0FQKTsKIAl9Ci0JbXV0ZXhfdW5sb2NrKCZkZXZfcHJpdi0+aHdfbXV0ZXgpOworCXNwaW5fdW5sb2NrKCZkZXZfcHJpdi0+Y2FwX2xvY2spOwogCiAJcmV0dXJuIDA7CiB9CkBAIC0xOTEsMTIgKzE5MSwxMiBAQAogCQlpZiAobnVtID4gU1ZHQTNEX0RFVkNBUF9NQVgpCiAJCQludW0gPSBTVkdBM0RfREVWQ0FQX01BWDsKIAotCQltdXRleF9sb2NrKCZkZXZfcHJpdi0+aHdfbXV0ZXgpOworCQlzcGluX2xvY2soJmRldl9wcml2LT5jYXBfbG9jayk7CiAJCWZvciAoaSA9IDA7IGkgPCBudW07ICsraSkgewogCQkJdm13X3dyaXRlKGRldl9wcml2LCBTVkdBX1JFR19ERVZfQ0FQLCBpKTsKIAkJCSpib3VuY2UzMisrID0gdm13X3JlYWQoZGV2X3ByaXYsIFNWR0FfUkVHX0RFVl9DQVApOwogCQl9Ci0JCW11dGV4X3VubG9jaygmZGV2X3ByaXYtPmh3X211dGV4KTsKKwkJc3Bpbl91bmxvY2soJmRldl9wcml2LT5jYXBfbG9jayk7CiAJfSBlbHNlIGlmIChnYl9vYmplY3RzKSB7CiAJCXJldCA9IHZtd19maWxsX2NvbXBhdF9jYXAoZGV2X3ByaXYsIGJvdW5jZSwgc2l6ZSk7CiAJCWlmICh1bmxpa2VseShyZXQgIT0gMCkpCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vdm13Z2Z4L3Ztd2dmeF9pcnEuYyBiL2RyaXZlcnMvZ3B1L2RybS92bXdnZngvdm13Z2Z4X2lycS5jCmluZGV4IDBjNDIzNzYuLjlmZTk4MjcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS92bXdnZngvdm13Z2Z4X2lycS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS92bXdnZngvdm13Z2Z4X2lycS5jCkBAIC02MiwxMyArNjIsOCBAQAogCiBzdGF0aWMgYm9vbCB2bXdfZmlmb19pZGxlKHN0cnVjdCB2bXdfcHJpdmF0ZSAqZGV2X3ByaXYsIHVpbnQzMl90IHNlcW5vKQogewotCXVpbnQzMl90IGJ1c3k7CiAKLQltdXRleF9sb2NrKCZkZXZfcHJpdi0+aHdfbXV0ZXgpOwotCWJ1c3kgPSB2bXdfcmVhZChkZXZfcHJpdiwgU1ZHQV9SRUdfQlVTWSk7Ci0JbXV0ZXhfdW5sb2NrKCZkZXZfcHJpdi0+aHdfbXV0ZXgpOwotCi0JcmV0dXJuIChidXN5ID09IDApOworCXJldHVybiAodm13X3JlYWQoZGV2X3ByaXYsIFNWR0FfUkVHX0JVU1kpID09IDApOwogfQogCiB2b2lkIHZtd191cGRhdGVfc2Vxbm8oc3RydWN0IHZtd19wcml2YXRlICpkZXZfcHJpdiwKQEAgLTE4NCw3ICsxNzksNyBAQAogCiB2b2lkIHZtd19zZXFub193YWl0ZXJfYWRkKHN0cnVjdCB2bXdfcHJpdmF0ZSAqZGV2X3ByaXYpCiB7Ci0JbXV0ZXhfbG9jaygmZGV2X3ByaXYtPmh3X211dGV4KTsKKwlzcGluX2xvY2soJmRldl9wcml2LT53YWl0ZXJfbG9jayk7CiAJaWYgKGRldl9wcml2LT5mZW5jZV9xdWV1ZV93YWl0ZXJzKysgPT0gMCkgewogCQl1bnNpZ25lZCBsb25nIGlycV9mbGFnczsKIApAQCAtMTk1LDEyICsxOTAsMTIgQEAKIAkJdm13X3dyaXRlKGRldl9wcml2LCBTVkdBX1JFR19JUlFNQVNLLCBkZXZfcHJpdi0+aXJxX21hc2spOwogCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZkZXZfcHJpdi0+aXJxX2xvY2ssIGlycV9mbGFncyk7CiAJfQotCW11dGV4X3VubG9jaygmZGV2X3ByaXYtPmh3X211dGV4KTsKKwlzcGluX3VubG9jaygmZGV2X3ByaXYtPndhaXRlcl9sb2NrKTsKIH0KIAogdm9pZCB2bXdfc2Vxbm9fd2FpdGVyX3JlbW92ZShzdHJ1Y3Qgdm13X3ByaXZhdGUgKmRldl9wcml2KQogewotCW11dGV4X2xvY2soJmRldl9wcml2LT5od19tdXRleCk7CisJc3Bpbl9sb2NrKCZkZXZfcHJpdi0+d2FpdGVyX2xvY2spOwogCWlmICgtLWRldl9wcml2LT5mZW5jZV9xdWV1ZV93YWl0ZXJzID09IDApIHsKIAkJdW5zaWduZWQgbG9uZyBpcnFfZmxhZ3M7CiAKQEAgLTIwOSwxMyArMjA0LDEzIEBACiAJCXZtd193cml0ZShkZXZfcHJpdiwgU1ZHQV9SRUdfSVJRTUFTSywgZGV2X3ByaXYtPmlycV9tYXNrKTsKIAkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZGV2X3ByaXYtPmlycV9sb2NrLCBpcnFfZmxhZ3MpOwogCX0KLQltdXRleF91bmxvY2soJmRldl9wcml2LT5od19tdXRleCk7CisJc3Bpbl91bmxvY2soJmRldl9wcml2LT53YWl0ZXJfbG9jayk7CiB9CiAKIAogdm9pZCB2bXdfZ29hbF93YWl0ZXJfYWRkKHN0cnVjdCB2bXdfcHJpdmF0ZSAqZGV2X3ByaXYpCiB7Ci0JbXV0ZXhfbG9jaygmZGV2X3ByaXYtPmh3X211dGV4KTsKKwlzcGluX2xvY2soJmRldl9wcml2LT53YWl0ZXJfbG9jayk7CiAJaWYgKGRldl9wcml2LT5nb2FsX3F1ZXVlX3dhaXRlcnMrKyA9PSAwKSB7CiAJCXVuc2lnbmVkIGxvbmcgaXJxX2ZsYWdzOwogCkBAIC0yMjYsMTIgKzIyMSwxMiBAQAogCQl2bXdfd3JpdGUoZGV2X3ByaXYsIFNWR0FfUkVHX0lSUU1BU0ssIGRldl9wcml2LT5pcnFfbWFzayk7CiAJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmRldl9wcml2LT5pcnFfbG9jaywgaXJxX2ZsYWdzKTsKIAl9Ci0JbXV0ZXhfdW5sb2NrKCZkZXZfcHJpdi0+aHdfbXV0ZXgpOworCXNwaW5fdW5sb2NrKCZkZXZfcHJpdi0+d2FpdGVyX2xvY2spOwogfQogCiB2b2lkIHZtd19nb2FsX3dhaXRlcl9yZW1vdmUoc3RydWN0IHZtd19wcml2YXRlICpkZXZfcHJpdikKIHsKLQltdXRleF9sb2NrKCZkZXZfcHJpdi0+aHdfbXV0ZXgpOworCXNwaW5fbG9jaygmZGV2X3ByaXYtPndhaXRlcl9sb2NrKTsKIAlpZiAoLS1kZXZfcHJpdi0+Z29hbF9xdWV1ZV93YWl0ZXJzID09IDApIHsKIAkJdW5zaWduZWQgbG9uZyBpcnFfZmxhZ3M7CiAKQEAgLTI0MCw3ICsyMzUsNyBAQAogCQl2bXdfd3JpdGUoZGV2X3ByaXYsIFNWR0FfUkVHX0lSUU1BU0ssIGRldl9wcml2LT5pcnFfbWFzayk7CiAJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmRldl9wcml2LT5pcnFfbG9jaywgaXJxX2ZsYWdzKTsKIAl9Ci0JbXV0ZXhfdW5sb2NrKCZkZXZfcHJpdi0+aHdfbXV0ZXgpOworCXNwaW5fdW5sb2NrKCZkZXZfcHJpdi0+d2FpdGVyX2xvY2spOwogfQogCiBpbnQgdm13X3dhaXRfc2Vxbm8oc3RydWN0IHZtd19wcml2YXRlICpkZXZfcHJpdiwKQEAgLTMxNSw5ICszMTAsNyBAQAogCWlmICghKGRldl9wcml2LT5jYXBhYmlsaXRpZXMgJiBTVkdBX0NBUF9JUlFNQVNLKSkKIAkJcmV0dXJuOwogCi0JbXV0ZXhfbG9jaygmZGV2X3ByaXYtPmh3X211dGV4KTsKIAl2bXdfd3JpdGUoZGV2X3ByaXYsIFNWR0FfUkVHX0lSUU1BU0ssIDApOwotCW11dGV4X3VubG9jaygmZGV2X3ByaXYtPmh3X211dGV4KTsKIAogCXN0YXR1cyA9IGlubChkZXZfcHJpdi0+aW9fc3RhcnQgKyBWTVdHRlhfSVJRU1RBVFVTX1BPUlQpOwogCW91dGwoc3RhdHVzLCBkZXZfcHJpdi0+aW9fc3RhcnQgKyBWTVdHRlhfSVJRU1RBVFVTX1BPUlQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3Ztd2dmeC92bXdnZnhfa21zLmMgYi9kcml2ZXJzL2dwdS9kcm0vdm13Z2Z4L3Ztd2dmeF9rbXMuYwppbmRleCAzNzI1YjUyLi44NzI1Yjc5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vdm13Z2Z4L3Ztd2dmeF9rbXMuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vdm13Z2Z4L3Ztd2dmeF9rbXMuYwpAQCAtMTgyOCw5ICsxODI4LDcgQEAKIAlzdHJ1Y3Qgdm13X3ByaXZhdGUgKmRldl9wcml2ID0gdm13X3ByaXYoZGV2KTsKIAlzdHJ1Y3Qgdm13X2Rpc3BsYXlfdW5pdCAqZHUgPSB2bXdfY29ubmVjdG9yX3RvX2R1KGNvbm5lY3Rvcik7CiAKLQltdXRleF9sb2NrKCZkZXZfcHJpdi0+aHdfbXV0ZXgpOwogCW51bV9kaXNwbGF5cyA9IHZtd19yZWFkKGRldl9wcml2LCBTVkdBX1JFR19OVU1fRElTUExBWVMpOwotCW11dGV4X3VubG9jaygmZGV2X3ByaXYtPmh3X211dGV4KTsKIAogCXJldHVybiAoKHZtd19jb25uZWN0b3JfdG9fZHUoY29ubmVjdG9yKS0+dW5pdCA8IG51bV9kaXNwbGF5cyAmJgogCQkgZHUtPnByZWZfYWN0aXZlKSA/CmRpZmYgLS1naXQgYS9kcml2ZXJzL2h2L3ZtYnVzX2Rydi5jIGIvZHJpdmVycy9odi92bWJ1c19kcnYuYwppbmRleCA0ZDZiMjY5Li5iYjM3MjViIDEwMDY0NAotLS0gYS9kcml2ZXJzL2h2L3ZtYnVzX2Rydi5jCisrKyBiL2RyaXZlcnMvaHYvdm1idXNfZHJ2LmMKQEAgLTg2MSw4ICs4NjEsOCBAQAogCQlicmVhazsKIAogCWNhc2UgQUNQSV9SRVNPVVJDRV9UWVBFX0FERFJFU1M2NDoKLQkJaHlwZXJ2X21taW8uc3RhcnQgPSByZXMtPmRhdGEuYWRkcmVzczY0Lm1pbmltdW07Ci0JCWh5cGVydl9tbWlvLmVuZCA9IHJlcy0+ZGF0YS5hZGRyZXNzNjQubWF4aW11bTsKKwkJaHlwZXJ2X21taW8uc3RhcnQgPSByZXMtPmRhdGEuYWRkcmVzczY0LmFkZHJlc3MubWluaW11bTsKKwkJaHlwZXJ2X21taW8uZW5kID0gcmVzLT5kYXRhLmFkZHJlc3M2NC5hZGRyZXNzLm1heGltdW07CiAJCWJyZWFrOwogCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9od21vbi9LY29uZmlnIGIvZHJpdmVycy9od21vbi9LY29uZmlnCmluZGV4IDY1MjljMDkuLmE3ZGUyNmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaHdtb24vS2NvbmZpZworKysgYi9kcml2ZXJzL2h3bW9uL0tjb25maWcKQEAgLTU3NCw2ICs1NzQsMTYgQEAKIAkgIGZvciB0aG9zZSBjaGFubmVscyBzcGVjaWZpZWQgaW4gdGhlIG1hcC4gIFRoaXMgbWFwIGNhbiBiZSBwcm92aWRlZAogCSAgZWl0aGVyIHZpYSBwbGF0Zm9ybSBkYXRhIG9yIHRoZSBkZXZpY2UgdHJlZSBiaW5kaW5ncy4KIAorY29uZmlnIFNFTlNPUlNfSTU1MDAKKwl0cmlzdGF0ZSAiSW50ZWwgNTUwMC81NTIwL1g1OCB0ZW1wZXJhdHVyZSBzZW5zb3IiCisJZGVwZW5kcyBvbiBYODYgJiYgUENJCisJaGVscAorCSAgSWYgeW91IHNheSB5ZXMgaGVyZSB5b3UgZ2V0IHN1cHBvcnQgZm9yIHRoZSB0ZW1wZXJhdHVyZQorCSAgc2Vuc29yIGluc2lkZSB0aGUgSW50ZWwgNTUwMCwgNTUyMCBhbmQgWDU4IGNoaXBzZXRzLgorCisJICBUaGlzIGRyaXZlciBjYW4gYWxzbyBiZSBidWlsdCBhcyBhIG1vZHVsZS4gSWYgc28sIHRoZSBtb2R1bGUKKwkgIHdpbGwgYmUgY2FsbGVkIGk1NTAwX3RlbXAuCisKIGNvbmZpZyBTRU5TT1JTX0NPUkVURU1QCiAJdHJpc3RhdGUgIkludGVsIENvcmUvQ29yZTIvQXRvbSB0ZW1wZXJhdHVyZSBzZW5zb3IiCiAJZGVwZW5kcyBvbiBYODYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUgYi9kcml2ZXJzL2h3bW9uL01ha2VmaWxlCmluZGV4IDY3MjgwNjQuLjZjOTQxNDcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaHdtb24vTWFrZWZpbGUKKysrIGIvZHJpdmVycy9od21vbi9NYWtlZmlsZQpAQCAtNjgsNiArNjgsNyBAQAogb2JqLSQoQ09ORklHX1NFTlNPUlNfSElINjEzMCkJKz0gaGloNjEzMC5vCiBvYmotJChDT05GSUdfU0VOU09SU19IVFUyMSkJKz0gaHR1MjEubwogb2JqLSQoQ09ORklHX1NFTlNPUlNfVUxUUkE0NSkJKz0gdWx0cmE0NV9lbnYubworb2JqLSQoQ09ORklHX1NFTlNPUlNfSTU1MDApCSs9IGk1NTAwX3RlbXAubwogb2JqLSQoQ09ORklHX1NFTlNPUlNfSTVLX0FNQikJKz0gaTVrX2FtYi5vCiBvYmotJChDT05GSUdfU0VOU09SU19JQk1BRU0pCSs9IGlibWFlbS5vCiBvYmotJChDT05GSUdfU0VOU09SU19JQk1QRVgpCSs9IGlibXBleC5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL2h3bW9uL2k1NTAwX3RlbXAuYyBiL2RyaXZlcnMvaHdtb24vaTU1MDBfdGVtcC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjNlM2NjYmYKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2h3bW9uL2k1NTAwX3RlbXAuYwpAQCAtMCwwICsxLDE0OSBAQAorLyoKKyAqIGk1NTAwX3RlbXAgLSBEcml2ZXIgZm9yIEludGVsIDU1MDAvNTUyMC9YNTggY2hpcHNldCB0aGVybWFsIHNlbnNvcgorICoKKyAqIENvcHlyaWdodCAoQykgMjAxMiwgMjAxNCBKZWFuIERlbHZhcmUgPGpkZWx2YXJlQHN1c2UuZGU+CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgorICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CisjaW5jbHVkZSA8bGludXgvc2xhYi5oPgorI2luY2x1ZGUgPGxpbnV4L2ppZmZpZXMuaD4KKyNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9wY2kuaD4KKyNpbmNsdWRlIDxsaW51eC9od21vbi5oPgorI2luY2x1ZGUgPGxpbnV4L2h3bW9uLXN5c2ZzLmg+CisjaW5jbHVkZSA8bGludXgvZXJyLmg+CisjaW5jbHVkZSA8bGludXgvbXV0ZXguaD4KKworLyogUmVnaXN0ZXIgZGVmaW5pdGlvbnMgZnJvbSBkYXRhc2hlZXQgKi8KKyNkZWZpbmUgUkVHX1RTVEhSQ0FUQQkweEUyCisjZGVmaW5lIFJFR19UU0NUUkwJMHhFOAorI2RlZmluZSBSRUdfVFNUSFJSUEVYCTB4RUIKKyNkZWZpbmUgUkVHX1RTVEhSTE8JMHhFQworI2RlZmluZSBSRUdfVFNUSFJISQkweEVFCisjZGVmaW5lIFJFR19DVEhJTlQJMHhGMAorI2RlZmluZSBSRUdfVFNGU0MJMHhGMworI2RlZmluZSBSRUdfQ1RTVFMJMHhGNAorI2RlZmluZSBSRUdfVFNUSFJSUVBJCTB4RjUKKyNkZWZpbmUgUkVHX0NUQ1RSTAkweEY3CisjZGVmaW5lIFJFR19UU1RJTUVSCTB4RjgKKworLyoKKyAqIFN5c2ZzIHN0dWZmCisgKi8KKworLyogU2Vuc29yIHJlc29sdXRpb24gOiAwLjUgZGVncmVlIEMgKi8KK3N0YXRpYyBzc2l6ZV90IHNob3dfdGVtcChzdHJ1Y3QgZGV2aWNlICpkZXYsCisJCQkgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmRldmF0dHIsIGNoYXIgKmJ1ZikKK3sKKwlzdHJ1Y3QgcGNpX2RldiAqcGRldiA9IHRvX3BjaV9kZXYoZGV2LT5wYXJlbnQpOworCWxvbmcgdGVtcDsKKwl1MTYgdHN0aHJoaTsKKwlzOCB0c2ZzYzsKKworCXBjaV9yZWFkX2NvbmZpZ193b3JkKHBkZXYsIFJFR19UU1RIUkhJLCAmdHN0aHJoaSk7CisJcGNpX3JlYWRfY29uZmlnX2J5dGUocGRldiwgUkVHX1RTRlNDLCAmdHNmc2MpOworCXRlbXAgPSAoKGxvbmcpdHN0aHJoaSAtIHRzZnNjKSAqIDUwMDsKKworCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVsZFxuIiwgdGVtcCk7Cit9CisKK3N0YXRpYyBzc2l6ZV90IHNob3dfdGhyZXNoKHN0cnVjdCBkZXZpY2UgKmRldiwKKwkJCSAgIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICpkZXZhdHRyLCBjaGFyICpidWYpCit7CisJc3RydWN0IHBjaV9kZXYgKnBkZXYgPSB0b19wY2lfZGV2KGRldi0+cGFyZW50KTsKKwlpbnQgcmVnID0gdG9fc2Vuc29yX2Rldl9hdHRyKGRldmF0dHIpLT5pbmRleDsKKwlsb25nIHRlbXA7CisJdTE2IHRzdGhyOworCisJcGNpX3JlYWRfY29uZmlnX3dvcmQocGRldiwgcmVnLCAmdHN0aHIpOworCXRlbXAgPSB0c3RociAqIDUwMDsKKworCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVsZFxuIiwgdGVtcCk7Cit9CisKK3N0YXRpYyBzc2l6ZV90IHNob3dfYWxhcm0oc3RydWN0IGRldmljZSAqZGV2LAorCQkJICBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqZGV2YXR0ciwgY2hhciAqYnVmKQoreworCXN0cnVjdCBwY2lfZGV2ICpwZGV2ID0gdG9fcGNpX2RldihkZXYtPnBhcmVudCk7CisJaW50IG5yID0gdG9fc2Vuc29yX2Rldl9hdHRyKGRldmF0dHIpLT5pbmRleDsKKwl1OCBjdHN0czsKKworCXBjaV9yZWFkX2NvbmZpZ19ieXRlKHBkZXYsIFJFR19DVFNUUywgJmN0c3RzKTsKKwlyZXR1cm4gc3ByaW50ZihidWYsICIldVxuIiwgKHVuc2lnbmVkIGludCljdHN0cyAmICgxIDw8IG5yKSk7Cit9CisKK3N0YXRpYyBERVZJQ0VfQVRUUih0ZW1wMV9pbnB1dCwgU19JUlVHTywgc2hvd190ZW1wLCBOVUxMKTsKK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDFfY3JpdCwgU19JUlVHTywgc2hvd190aHJlc2gsIE5VTEwsIDB4RTIpOworc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wMV9tYXhfaHlzdCwgU19JUlVHTywgc2hvd190aHJlc2gsIE5VTEwsIDB4RUMpOworc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wMV9tYXgsIFNfSVJVR08sIHNob3dfdGhyZXNoLCBOVUxMLCAweEVFKTsKK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDFfY3JpdF9hbGFybSwgU19JUlVHTywgc2hvd19hbGFybSwgTlVMTCwgMCk7CitzdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAxX21heF9hbGFybSwgU19JUlVHTywgc2hvd19hbGFybSwgTlVMTCwgMSk7CisKK3N0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICppNTUwMF90ZW1wX2F0dHJzW10gPSB7CisJJmRldl9hdHRyX3RlbXAxX2lucHV0LmF0dHIsCisJJnNlbnNvcl9kZXZfYXR0cl90ZW1wMV9jcml0LmRldl9hdHRyLmF0dHIsCisJJnNlbnNvcl9kZXZfYXR0cl90ZW1wMV9tYXhfaHlzdC5kZXZfYXR0ci5hdHRyLAorCSZzZW5zb3JfZGV2X2F0dHJfdGVtcDFfbWF4LmRldl9hdHRyLmF0dHIsCisJJnNlbnNvcl9kZXZfYXR0cl90ZW1wMV9jcml0X2FsYXJtLmRldl9hdHRyLmF0dHIsCisJJnNlbnNvcl9kZXZfYXR0cl90ZW1wMV9tYXhfYWxhcm0uZGV2X2F0dHIuYXR0ciwKKwlOVUxMCit9OworCitBVFRSSUJVVEVfR1JPVVBTKGk1NTAwX3RlbXApOworCitzdGF0aWMgY29uc3Qgc3RydWN0IHBjaV9kZXZpY2VfaWQgaTU1MDBfdGVtcF9pZHNbXSA9IHsKKwl7IFBDSV9ERVZJQ0UoUENJX1ZFTkRPUl9JRF9JTlRFTCwgMHgzNDM4KSB9LAorCXsgMCB9LAorfTsKKworTU9EVUxFX0RFVklDRV9UQUJMRShwY2ksIGk1NTAwX3RlbXBfaWRzKTsKKworc3RhdGljIGludCBpNTUwMF90ZW1wX3Byb2JlKHN0cnVjdCBwY2lfZGV2ICpwZGV2LAorCQkJICAgIGNvbnN0IHN0cnVjdCBwY2lfZGV2aWNlX2lkICppZCkKK3sKKwlpbnQgZXJyOworCXN0cnVjdCBkZXZpY2UgKmh3bW9uX2RldjsKKwl1MzIgdHN0aW1lcjsKKwlzOCB0c2ZzYzsKKworCWVyciA9IHBjaV9lbmFibGVfZGV2aWNlKHBkZXYpOworCWlmIChlcnIpIHsKKwkJZGV2X2VycigmcGRldi0+ZGV2LCAiRmFpbGVkIHRvIGVuYWJsZSBkZXZpY2VcbiIpOworCQlyZXR1cm4gZXJyOworCX0KKworCXBjaV9yZWFkX2NvbmZpZ19ieXRlKHBkZXYsIFJFR19UU0ZTQywgJnRzZnNjKTsKKwlwY2lfcmVhZF9jb25maWdfZHdvcmQocGRldiwgUkVHX1RTVElNRVIsICZ0c3RpbWVyKTsKKwlpZiAodHNmc2MgPT0gMHg3RiAmJiB0c3RpbWVyID09IDB4MDdEMzBENDApIHsKKwkJZGV2X25vdGljZSgmcGRldi0+ZGV2LCAiU2Vuc29yIHNlZW1zIHRvIGJlIGRpc2FibGVkXG4iKTsKKwkJcmV0dXJuIC1FTk9ERVY7CisJfQorCisJaHdtb25fZGV2ID0gZGV2bV9od21vbl9kZXZpY2VfcmVnaXN0ZXJfd2l0aF9ncm91cHMoJnBkZXYtPmRldiwKKwkJCQkJCQkgICAiaW50ZWw1NTAwIiwgTlVMTCwKKwkJCQkJCQkgICBpNTUwMF90ZW1wX2dyb3Vwcyk7CisJcmV0dXJuIFBUUl9FUlJfT1JfWkVSTyhod21vbl9kZXYpOworfQorCitzdGF0aWMgc3RydWN0IHBjaV9kcml2ZXIgaTU1MDBfdGVtcF9kcml2ZXIgPSB7CisJLm5hbWUgPSAiaTU1MDBfdGVtcCIsCisJLmlkX3RhYmxlID0gaTU1MDBfdGVtcF9pZHMsCisJLnByb2JlID0gaTU1MDBfdGVtcF9wcm9iZSwKK307CisKK21vZHVsZV9wY2lfZHJpdmVyKGk1NTAwX3RlbXBfZHJpdmVyKTsKKworTU9EVUxFX0FVVEhPUigiSmVhbiBEZWx2YXJlIDxqZGVsdmFyZUBzdXNlLmRlPiIpOworTU9EVUxFX0RFU0NSSVBUSU9OKCJJbnRlbCA1NTAwLzU1MjAvWDU4IGNoaXBzZXQgdGhlcm1hbCBzZW5zb3IgZHJpdmVyIik7CitNT0RVTEVfTElDRU5TRSgiR1BMIik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2kyYy9idXNzZXMvS2NvbmZpZyBiL2RyaXZlcnMvaTJjL2J1c3Nlcy9LY29uZmlnCmluZGV4IDMxZTgzMDguLmFiODM4ZDkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaTJjL2J1c3Nlcy9LY29uZmlnCisrKyBiL2RyaXZlcnMvaTJjL2J1c3Nlcy9LY29uZmlnCkBAIC04ODEsNiArODgxLDcgQEAKIGNvbmZpZyBJMkNfUkNBUgogCXRyaXN0YXRlICJSZW5lc2FzIFItQ2FyIEkyQyBDb250cm9sbGVyIgogCWRlcGVuZHMgb24gQVJDSF9TSE1PQklMRSB8fCBDT01QSUxFX1RFU1QKKwlzZWxlY3QgSTJDX1NMQVZFCiAJaGVscAogCSAgSWYgeW91IHNheSB5ZXMgdG8gdGhpcyBvcHRpb24sIHN1cHBvcnQgd2lsbCBiZSBpbmNsdWRlZCBmb3IgdGhlCiAJICBSLUNhciBJMkMgY29udHJvbGxlci4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvaTJjL2J1c3Nlcy9pMmMtczNjMjQxMC5jIGIvZHJpdmVycy9pMmMvYnVzc2VzL2kyYy1zM2MyNDEwLmMKaW5kZXggYmZmMjBhNS4uOTU4YzhkYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9pMmMvYnVzc2VzL2kyYy1zM2MyNDEwLmMKKysrIGIvZHJpdmVycy9pMmMvYnVzc2VzL2kyYy1zM2MyNDEwLmMKQEAgLTc4NSwxNCArNzg1LDE2IEBACiAJaW50IHJldDsKIAogCXBtX3J1bnRpbWVfZ2V0X3N5bmMoJmFkYXAtPmRldik7Ci0JY2xrX3ByZXBhcmVfZW5hYmxlKGkyYy0+Y2xrKTsKKwlyZXQgPSBjbGtfZW5hYmxlKGkyYy0+Y2xrKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OwogCiAJZm9yIChyZXRyeSA9IDA7IHJldHJ5IDwgYWRhcC0+cmV0cmllczsgcmV0cnkrKykgewogCiAJCXJldCA9IHMzYzI0eHhfaTJjX2RveGZlcihpMmMsIG1zZ3MsIG51bSk7CiAKIAkJaWYgKHJldCAhPSAtRUFHQUlOKSB7Ci0JCQljbGtfZGlzYWJsZV91bnByZXBhcmUoaTJjLT5jbGspOworCQkJY2xrX2Rpc2FibGUoaTJjLT5jbGspOwogCQkJcG1fcnVudGltZV9wdXQoJmFkYXAtPmRldik7CiAJCQlyZXR1cm4gcmV0OwogCQl9CkBAIC04MDIsNyArODA0LDcgQEAKIAkJdWRlbGF5KDEwMCk7CiAJfQogCi0JY2xrX2Rpc2FibGVfdW5wcmVwYXJlKGkyYy0+Y2xrKTsKKwljbGtfZGlzYWJsZShpMmMtPmNsayk7CiAJcG1fcnVudGltZV9wdXQoJmFkYXAtPmRldik7CiAJcmV0dXJuIC1FUkVNT1RFSU87CiB9CkBAIC0xMTk3LDcgKzExOTksNyBAQAogCiAJY2xrX3ByZXBhcmVfZW5hYmxlKGkyYy0+Y2xrKTsKIAlyZXQgPSBzM2MyNHh4X2kyY19pbml0KGkyYyk7Ci0JY2xrX2Rpc2FibGVfdW5wcmVwYXJlKGkyYy0+Y2xrKTsKKwljbGtfZGlzYWJsZShpMmMtPmNsayk7CiAJaWYgKHJldCAhPSAwKSB7CiAJCWRldl9lcnIoJnBkZXYtPmRldiwgIkkyQyBjb250cm9sbGVyIGluaXQgZmFpbGVkXG4iKTsKIAkJcmV0dXJuIHJldDsKQEAgLTEyMTAsNiArMTIxMiw3IEBACiAJCWkyYy0+aXJxID0gcmV0ID0gcGxhdGZvcm1fZ2V0X2lycShwZGV2LCAwKTsKIAkJaWYgKHJldCA8PSAwKSB7CiAJCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJjYW5ub3QgZmluZCBJUlFcbiIpOworCQkJY2xrX3VucHJlcGFyZShpMmMtPmNsayk7CiAJCQlyZXR1cm4gcmV0OwogCQl9CiAKQEAgLTEyMTgsNiArMTIyMSw3IEBACiAKIAkJaWYgKHJldCAhPSAwKSB7CiAJCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJjYW5ub3QgY2xhaW0gSVJRICVkXG4iLCBpMmMtPmlycSk7CisJCQljbGtfdW5wcmVwYXJlKGkyYy0+Y2xrKTsKIAkJCXJldHVybiByZXQ7CiAJCX0KIAl9CkBAIC0xMjI1LDYgKzEyMjksNyBAQAogCXJldCA9IHMzYzI0eHhfaTJjX3JlZ2lzdGVyX2NwdWZyZXEoaTJjKTsKIAlpZiAocmV0IDwgMCkgewogCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJmYWlsZWQgdG8gcmVnaXN0ZXIgY3B1ZnJlcSBub3RpZmllclxuIik7CisJCWNsa191bnByZXBhcmUoaTJjLT5jbGspOwogCQlyZXR1cm4gcmV0OwogCX0KIApAQCAtMTI0MSw2ICsxMjQ2LDcgQEAKIAlpZiAocmV0IDwgMCkgewogCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJmYWlsZWQgdG8gYWRkIGJ1cyB0byBpMmMgY29yZVxuIik7CiAJCXMzYzI0eHhfaTJjX2RlcmVnaXN0ZXJfY3B1ZnJlcShpMmMpOworCQljbGtfdW5wcmVwYXJlKGkyYy0+Y2xrKTsKIAkJcmV0dXJuIHJldDsKIAl9CiAKQEAgLTEyNjIsNiArMTI2OCw4IEBACiB7CiAJc3RydWN0IHMzYzI0eHhfaTJjICppMmMgPSBwbGF0Zm9ybV9nZXRfZHJ2ZGF0YShwZGV2KTsKIAorCWNsa191bnByZXBhcmUoaTJjLT5jbGspOworCiAJcG1fcnVudGltZV9kaXNhYmxlKCZpMmMtPmFkYXAuZGV2KTsKIAlwbV9ydW50aW1lX2Rpc2FibGUoJnBkZXYtPmRldik7CiAKQEAgLTEyOTMsMTMgKzEzMDEsMTYgQEAKIHsKIAlzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2ID0gdG9fcGxhdGZvcm1fZGV2aWNlKGRldik7CiAJc3RydWN0IHMzYzI0eHhfaTJjICppMmMgPSBwbGF0Zm9ybV9nZXRfZHJ2ZGF0YShwZGV2KTsKKwlpbnQgcmV0OwogCiAJaWYgKCFJU19FUlIoaTJjLT5zeXNyZWcpKQogCQlyZWdtYXBfd3JpdGUoaTJjLT5zeXNyZWcsIEVYWU5PUzVfU1lTX0kyQ19DRkcsIGkyYy0+c3lzX2kyY19jZmcpOwogCi0JY2xrX3ByZXBhcmVfZW5hYmxlKGkyYy0+Y2xrKTsKKwlyZXQgPSBjbGtfZW5hYmxlKGkyYy0+Y2xrKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OwogCXMzYzI0eHhfaTJjX2luaXQoaTJjKTsKLQljbGtfZGlzYWJsZV91bnByZXBhcmUoaTJjLT5jbGspOworCWNsa19kaXNhYmxlKGkyYy0+Y2xrKTsKIAlpMmMtPnN1c3BlbmRlZCA9IDA7CiAKIAlyZXR1cm4gMDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaTJjL2J1c3Nlcy9pMmMtc2hfbW9iaWxlLmMgYi9kcml2ZXJzL2kyYy9idXNzZXMvaTJjLXNoX21vYmlsZS5jCmluZGV4IDQ0MGQ1ZGIuLjAwNzgxOGIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaTJjL2J1c3Nlcy9pMmMtc2hfbW9iaWxlLmMKKysrIGIvZHJpdmVycy9pMmMvYnVzc2VzL2kyYy1zaF9tb2JpbGUuYwpAQCAtMTM5LDYgKzEzOSw3IEBACiAJaW50IHBvczsKIAlpbnQgc3I7CiAJYm9vbCBzZW5kX3N0b3A7CisJYm9vbCBzdG9wX2FmdGVyX2RtYTsKIAogCXN0cnVjdCByZXNvdXJjZSAqcmVzOwogCXN0cnVjdCBkbWFfY2hhbiAqZG1hX3R4OwpAQCAtNDA3LDcgKzQwOCw3IEBACiAKIAlpZiAocGQtPnBvcyA9PSBwZC0+bXNnLT5sZW4pIHsKIAkJLyogU2VuZCBzdG9wIGlmIHdlIGhhdmVuJ3QgeWV0IChETUEgY2FzZSkgKi8KLQkJaWYgKHBkLT5zZW5kX3N0b3AgJiYgKGlpY19yZChwZCwgSUNDUikgJiBJQ0NSX0JCU1kpKQorCQlpZiAocGQtPnNlbmRfc3RvcCAmJiBwZC0+c3RvcF9hZnRlcl9kbWEpCiAJCQlpMmNfb3AocGQsIE9QX1RYX1NUT1AsIDApOwogCQlyZXR1cm4gMTsKIAl9CkBAIC00NDksNiArNDUwLDEzIEBACiAJCXJlYWxfcG9zID0gcGQtPnBvcyAtIDI7CiAKIAkJaWYgKHBkLT5wb3MgPT0gcGQtPm1zZy0+bGVuKSB7CisJCQlpZiAocGQtPnN0b3BfYWZ0ZXJfZG1hKSB7CisJCQkJLyogU2ltdWxhdGUgUElPIGVuZCBjb25kaXRpb24gYWZ0ZXIgRE1BIHRyYW5zZmVyICovCisJCQkJaTJjX29wKHBkLCBPUF9SWF9TVE9QLCAwKTsKKwkJCQlwZC0+cG9zKys7CisJCQkJYnJlYWs7CisJCQl9CisKIAkJCWlmIChyZWFsX3BvcyA8IDApIHsKIAkJCQlpMmNfb3AocGQsIE9QX1JYX1NUT1AsIDApOwogCQkJCWJyZWFrOwpAQCAtNTM2LDYgKzU0NCw3IEBACiAKIAlzaF9tb2JpbGVfaTJjX2RtYV91bm1hcChwZCk7CiAJcGQtPnBvcyA9IHBkLT5tc2ctPmxlbjsKKwlwZC0+c3RvcF9hZnRlcl9kbWEgPSB0cnVlOwogCiAJaWljX3NldF9jbHIocGQsIElDSUMsIDAsIElDSUNfVERNQUUgfCBJQ0lDX1JETUFFKTsKIH0KQEAgLTcyNiw2ICs3MzUsNyBAQAogCQlib29sIGRvX3N0YXJ0ID0gcGQtPnNlbmRfc3RvcCB8fCAhaTsKIAkJbXNnID0gJm1zZ3NbaV07CiAJCXBkLT5zZW5kX3N0b3AgPSBpID09IG51bSAtIDEgfHwgbXNnLT5mbGFncyAmIEkyQ19NX1NUT1A7CisJCXBkLT5zdG9wX2FmdGVyX2RtYSA9IGZhbHNlOwogCiAJCWVyciA9IHN0YXJ0X2NoKHBkLCBtc2csIGRvX3N0YXJ0KTsKIAkJaWYgKGVycikKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaTJjL2kyYy1jb3JlLmMgYi9kcml2ZXJzL2kyYy9pMmMtY29yZS5jCmluZGV4IDM5ZDI1YTguLmU5ZWFlNTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaTJjL2kyYy1jb3JlLmMKKysrIGIvZHJpdmVycy9pMmMvaTJjLWNvcmUuYwpAQCAtMjk3Miw2ICsyOTcyLDcgQEAKIH0KIEVYUE9SVF9TWU1CT0woaTJjX3NtYnVzX3hmZXIpOwogCisjaWYgSVNfRU5BQkxFRChDT05GSUdfSTJDX1NMQVZFKQogaW50IGkyY19zbGF2ZV9yZWdpc3RlcihzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50LCBpMmNfc2xhdmVfY2JfdCBzbGF2ZV9jYikKIHsKIAlpbnQgcmV0OwpAQCAtMzAxOSw2ICszMDIwLDcgQEAKIAlyZXR1cm4gcmV0OwogfQogRVhQT1JUX1NZTUJPTF9HUEwoaTJjX3NsYXZlX3VucmVnaXN0ZXIpOworI2VuZGlmCiAKIE1PRFVMRV9BVVRIT1IoIlNpbW9uIEcuIFZvZ2wgPHNpbW9uQHRrLnVuaS1saW56LmFjLmF0PiIpOwogTU9EVUxFX0RFU0NSSVBUSU9OKCJJMkMtQnVzIG1haW4gbW9kdWxlIik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2kyYy9pMmMtc2xhdmUtZWVwcm9tLmMgYi9kcml2ZXJzL2kyYy9pMmMtc2xhdmUtZWVwcm9tLmMKaW5kZXggNjYzMTQwMC4uY2Y5YjA5ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9pMmMvaTJjLXNsYXZlLWVlcHJvbS5jCisrKyBiL2RyaXZlcnMvaTJjL2kyYy1zbGF2ZS1lZXByb20uYwpAQCAtNzQsNyArNzQsNyBAQAogCXN0cnVjdCBlZXByb21fZGF0YSAqZWVwcm9tOwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKLQlpZiAob2ZmICsgY291bnQgPj0gYXR0ci0+c2l6ZSkKKwlpZiAob2ZmICsgY291bnQgPiBhdHRyLT5zaXplKQogCQlyZXR1cm4gLUVGQklHOwogCiAJZWVwcm9tID0gZGV2X2dldF9kcnZkYXRhKGNvbnRhaW5lcl9vZihrb2JqLCBzdHJ1Y3QgZGV2aWNlLCBrb2JqKSk7CkBAIC05Miw3ICs5Miw3IEBACiAJc3RydWN0IGVlcHJvbV9kYXRhICplZXByb207CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAotCWlmIChvZmYgKyBjb3VudCA+PSBhdHRyLT5zaXplKQorCWlmIChvZmYgKyBjb3VudCA+IGF0dHItPnNpemUpCiAJCXJldHVybiAtRUZCSUc7CiAKIAllZXByb20gPSBkZXZfZ2V0X2RydmRhdGEoY29udGFpbmVyX29mKGtvYmosIHN0cnVjdCBkZXZpY2UsIGtvYmopKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5maW5pYmFuZC9jb3JlL3V2ZXJicy5oIGIvZHJpdmVycy9pbmZpbmliYW5kL2NvcmUvdXZlcmJzLmgKaW5kZXggYjcxNmIwOC4uNjQzYzA4YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbmZpbmliYW5kL2NvcmUvdXZlcmJzLmgKKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL2NvcmUvdXZlcmJzLmgKQEAgLTI1OCw2ICsyNTgsNSBAQAogCiBJQl9VVkVSQlNfREVDTEFSRV9FWF9DTUQoY3JlYXRlX2Zsb3cpOwogSUJfVVZFUkJTX0RFQ0xBUkVfRVhfQ01EKGRlc3Ryb3lfZmxvdyk7Ci1JQl9VVkVSQlNfREVDTEFSRV9FWF9DTUQocXVlcnlfZGV2aWNlKTsKIAogI2VuZGlmIC8qIFVWRVJCU19IICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvY29yZS91dmVyYnNfY21kLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvY29yZS91dmVyYnNfY21kLmMKaW5kZXggNTMyZDhlYmE4Li5iNzk0M2ZmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvY29yZS91dmVyYnNfY21kLmMKKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL2NvcmUvdXZlcmJzX2NtZC5jCkBAIC00MDAsNTIgKzQwMCw2IEBACiAJcmV0dXJuIHJldDsKIH0KIAotc3RhdGljIHZvaWQgY29weV9xdWVyeV9kZXZfZmllbGRzKHN0cnVjdCBpYl91dmVyYnNfZmlsZSAqZmlsZSwKLQkJCQkgIHN0cnVjdCBpYl91dmVyYnNfcXVlcnlfZGV2aWNlX3Jlc3AgKnJlc3AsCi0JCQkJICBzdHJ1Y3QgaWJfZGV2aWNlX2F0dHIgKmF0dHIpCi17Ci0JcmVzcC0+ZndfdmVyCQk9IGF0dHItPmZ3X3ZlcjsKLQlyZXNwLT5ub2RlX2d1aWQJCT0gZmlsZS0+ZGV2aWNlLT5pYl9kZXYtPm5vZGVfZ3VpZDsKLQlyZXNwLT5zeXNfaW1hZ2VfZ3VpZAk9IGF0dHItPnN5c19pbWFnZV9ndWlkOwotCXJlc3AtPm1heF9tcl9zaXplCT0gYXR0ci0+bWF4X21yX3NpemU7Ci0JcmVzcC0+cGFnZV9zaXplX2NhcAk9IGF0dHItPnBhZ2Vfc2l6ZV9jYXA7Ci0JcmVzcC0+dmVuZG9yX2lkCQk9IGF0dHItPnZlbmRvcl9pZDsKLQlyZXNwLT52ZW5kb3JfcGFydF9pZAk9IGF0dHItPnZlbmRvcl9wYXJ0X2lkOwotCXJlc3AtPmh3X3ZlcgkJPSBhdHRyLT5od192ZXI7Ci0JcmVzcC0+bWF4X3FwCQk9IGF0dHItPm1heF9xcDsKLQlyZXNwLT5tYXhfcXBfd3IJCT0gYXR0ci0+bWF4X3FwX3dyOwotCXJlc3AtPmRldmljZV9jYXBfZmxhZ3MJPSBhdHRyLT5kZXZpY2VfY2FwX2ZsYWdzOwotCXJlc3AtPm1heF9zZ2UJCT0gYXR0ci0+bWF4X3NnZTsKLQlyZXNwLT5tYXhfc2dlX3JkCT0gYXR0ci0+bWF4X3NnZV9yZDsKLQlyZXNwLT5tYXhfY3EJCT0gYXR0ci0+bWF4X2NxOwotCXJlc3AtPm1heF9jcWUJCT0gYXR0ci0+bWF4X2NxZTsKLQlyZXNwLT5tYXhfbXIJCT0gYXR0ci0+bWF4X21yOwotCXJlc3AtPm1heF9wZAkJPSBhdHRyLT5tYXhfcGQ7Ci0JcmVzcC0+bWF4X3FwX3JkX2F0b20JPSBhdHRyLT5tYXhfcXBfcmRfYXRvbTsKLQlyZXNwLT5tYXhfZWVfcmRfYXRvbQk9IGF0dHItPm1heF9lZV9yZF9hdG9tOwotCXJlc3AtPm1heF9yZXNfcmRfYXRvbQk9IGF0dHItPm1heF9yZXNfcmRfYXRvbTsKLQlyZXNwLT5tYXhfcXBfaW5pdF9yZF9hdG9tCT0gYXR0ci0+bWF4X3FwX2luaXRfcmRfYXRvbTsKLQlyZXNwLT5tYXhfZWVfaW5pdF9yZF9hdG9tCT0gYXR0ci0+bWF4X2VlX2luaXRfcmRfYXRvbTsKLQlyZXNwLT5hdG9taWNfY2FwCQk9IGF0dHItPmF0b21pY19jYXA7Ci0JcmVzcC0+bWF4X2VlCQkJPSBhdHRyLT5tYXhfZWU7Ci0JcmVzcC0+bWF4X3JkZAkJCT0gYXR0ci0+bWF4X3JkZDsKLQlyZXNwLT5tYXhfbXcJCQk9IGF0dHItPm1heF9tdzsKLQlyZXNwLT5tYXhfcmF3X2lwdjZfcXAJCT0gYXR0ci0+bWF4X3Jhd19pcHY2X3FwOwotCXJlc3AtPm1heF9yYXdfZXRoeV9xcAkJPSBhdHRyLT5tYXhfcmF3X2V0aHlfcXA7Ci0JcmVzcC0+bWF4X21jYXN0X2dycAkJPSBhdHRyLT5tYXhfbWNhc3RfZ3JwOwotCXJlc3AtPm1heF9tY2FzdF9xcF9hdHRhY2gJPSBhdHRyLT5tYXhfbWNhc3RfcXBfYXR0YWNoOwotCXJlc3AtPm1heF90b3RhbF9tY2FzdF9xcF9hdHRhY2gJPSBhdHRyLT5tYXhfdG90YWxfbWNhc3RfcXBfYXR0YWNoOwotCXJlc3AtPm1heF9haAkJCT0gYXR0ci0+bWF4X2FoOwotCXJlc3AtPm1heF9mbXIJCQk9IGF0dHItPm1heF9mbXI7Ci0JcmVzcC0+bWF4X21hcF9wZXJfZm1yCQk9IGF0dHItPm1heF9tYXBfcGVyX2ZtcjsKLQlyZXNwLT5tYXhfc3JxCQkJPSBhdHRyLT5tYXhfc3JxOwotCXJlc3AtPm1heF9zcnFfd3IJCT0gYXR0ci0+bWF4X3NycV93cjsKLQlyZXNwLT5tYXhfc3JxX3NnZQkJPSBhdHRyLT5tYXhfc3JxX3NnZTsKLQlyZXNwLT5tYXhfcGtleXMJCQk9IGF0dHItPm1heF9wa2V5czsKLQlyZXNwLT5sb2NhbF9jYV9hY2tfZGVsYXkJPSBhdHRyLT5sb2NhbF9jYV9hY2tfZGVsYXk7Ci0JcmVzcC0+cGh5c19wb3J0X2NudAkJPSBmaWxlLT5kZXZpY2UtPmliX2Rldi0+cGh5c19wb3J0X2NudDsKLX0KLQogc3NpemVfdCBpYl91dmVyYnNfcXVlcnlfZGV2aWNlKHN0cnVjdCBpYl91dmVyYnNfZmlsZSAqZmlsZSwKIAkJCSAgICAgICBjb25zdCBjaGFyIF9fdXNlciAqYnVmLAogCQkJICAgICAgIGludCBpbl9sZW4sIGludCBvdXRfbGVuKQpAQCAtNDY2LDcgKzQyMCw0NyBAQAogCQlyZXR1cm4gcmV0OwogCiAJbWVtc2V0KCZyZXNwLCAwLCBzaXplb2YgcmVzcCk7Ci0JY29weV9xdWVyeV9kZXZfZmllbGRzKGZpbGUsICZyZXNwLCAmYXR0cik7CisKKwlyZXNwLmZ3X3ZlciAJCSAgICAgICA9IGF0dHIuZndfdmVyOworCXJlc3Aubm9kZV9ndWlkIAkJICAgICAgID0gZmlsZS0+ZGV2aWNlLT5pYl9kZXYtPm5vZGVfZ3VpZDsKKwlyZXNwLnN5c19pbWFnZV9ndWlkIAkgICAgICAgPSBhdHRyLnN5c19pbWFnZV9ndWlkOworCXJlc3AubWF4X21yX3NpemUgCSAgICAgICA9IGF0dHIubWF4X21yX3NpemU7CisJcmVzcC5wYWdlX3NpemVfY2FwIAkgICAgICAgPSBhdHRyLnBhZ2Vfc2l6ZV9jYXA7CisJcmVzcC52ZW5kb3JfaWQgCQkgICAgICAgPSBhdHRyLnZlbmRvcl9pZDsKKwlyZXNwLnZlbmRvcl9wYXJ0X2lkIAkgICAgICAgPSBhdHRyLnZlbmRvcl9wYXJ0X2lkOworCXJlc3AuaHdfdmVyIAkJICAgICAgID0gYXR0ci5od192ZXI7CisJcmVzcC5tYXhfcXAgCQkgICAgICAgPSBhdHRyLm1heF9xcDsKKwlyZXNwLm1heF9xcF93ciAJCSAgICAgICA9IGF0dHIubWF4X3FwX3dyOworCXJlc3AuZGV2aWNlX2NhcF9mbGFncyAJICAgICAgID0gYXR0ci5kZXZpY2VfY2FwX2ZsYWdzOworCXJlc3AubWF4X3NnZSAJCSAgICAgICA9IGF0dHIubWF4X3NnZTsKKwlyZXNwLm1heF9zZ2VfcmQgCSAgICAgICA9IGF0dHIubWF4X3NnZV9yZDsKKwlyZXNwLm1heF9jcSAJCSAgICAgICA9IGF0dHIubWF4X2NxOworCXJlc3AubWF4X2NxZSAJCSAgICAgICA9IGF0dHIubWF4X2NxZTsKKwlyZXNwLm1heF9tciAJCSAgICAgICA9IGF0dHIubWF4X21yOworCXJlc3AubWF4X3BkIAkJICAgICAgID0gYXR0ci5tYXhfcGQ7CisJcmVzcC5tYXhfcXBfcmRfYXRvbSAJICAgICAgID0gYXR0ci5tYXhfcXBfcmRfYXRvbTsKKwlyZXNwLm1heF9lZV9yZF9hdG9tIAkgICAgICAgPSBhdHRyLm1heF9lZV9yZF9hdG9tOworCXJlc3AubWF4X3Jlc19yZF9hdG9tIAkgICAgICAgPSBhdHRyLm1heF9yZXNfcmRfYXRvbTsKKwlyZXNwLm1heF9xcF9pbml0X3JkX2F0b20gICAgICAgPSBhdHRyLm1heF9xcF9pbml0X3JkX2F0b207CisJcmVzcC5tYXhfZWVfaW5pdF9yZF9hdG9tICAgICAgID0gYXR0ci5tYXhfZWVfaW5pdF9yZF9hdG9tOworCXJlc3AuYXRvbWljX2NhcCAJICAgICAgID0gYXR0ci5hdG9taWNfY2FwOworCXJlc3AubWF4X2VlIAkJICAgICAgID0gYXR0ci5tYXhfZWU7CisJcmVzcC5tYXhfcmRkIAkJICAgICAgID0gYXR0ci5tYXhfcmRkOworCXJlc3AubWF4X213IAkJICAgICAgID0gYXR0ci5tYXhfbXc7CisJcmVzcC5tYXhfcmF3X2lwdjZfcXAgCSAgICAgICA9IGF0dHIubWF4X3Jhd19pcHY2X3FwOworCXJlc3AubWF4X3Jhd19ldGh5X3FwIAkgICAgICAgPSBhdHRyLm1heF9yYXdfZXRoeV9xcDsKKwlyZXNwLm1heF9tY2FzdF9ncnAgCSAgICAgICA9IGF0dHIubWF4X21jYXN0X2dycDsKKwlyZXNwLm1heF9tY2FzdF9xcF9hdHRhY2ggICAgICAgPSBhdHRyLm1heF9tY2FzdF9xcF9hdHRhY2g7CisJcmVzcC5tYXhfdG90YWxfbWNhc3RfcXBfYXR0YWNoID0gYXR0ci5tYXhfdG90YWxfbWNhc3RfcXBfYXR0YWNoOworCXJlc3AubWF4X2FoIAkJICAgICAgID0gYXR0ci5tYXhfYWg7CisJcmVzcC5tYXhfZm1yIAkJICAgICAgID0gYXR0ci5tYXhfZm1yOworCXJlc3AubWF4X21hcF9wZXJfZm1yIAkgICAgICAgPSBhdHRyLm1heF9tYXBfcGVyX2ZtcjsKKwlyZXNwLm1heF9zcnEgCQkgICAgICAgPSBhdHRyLm1heF9zcnE7CisJcmVzcC5tYXhfc3JxX3dyIAkgICAgICAgPSBhdHRyLm1heF9zcnFfd3I7CisJcmVzcC5tYXhfc3JxX3NnZSAJICAgICAgID0gYXR0ci5tYXhfc3JxX3NnZTsKKwlyZXNwLm1heF9wa2V5cyAJCSAgICAgICA9IGF0dHIubWF4X3BrZXlzOworCXJlc3AubG9jYWxfY2FfYWNrX2RlbGF5ICAgICAgICA9IGF0dHIubG9jYWxfY2FfYWNrX2RlbGF5OworCXJlc3AucGh5c19wb3J0X2NudAkgICAgICAgPSBmaWxlLT5kZXZpY2UtPmliX2Rldi0+cGh5c19wb3J0X2NudDsKIAogCWlmIChjb3B5X3RvX3VzZXIoKHZvaWQgX191c2VyICopICh1bnNpZ25lZCBsb25nKSBjbWQucmVzcG9uc2UsCiAJCQkgJnJlc3AsIHNpemVvZiByZXNwKSkKQEAgLTMyOTMsNTIgKzMyODcsMyBAQAogCiAJcmV0dXJuIHJldCA/IHJldCA6IGluX2xlbjsKIH0KLQotaW50IGliX3V2ZXJic19leF9xdWVyeV9kZXZpY2Uoc3RydWN0IGliX3V2ZXJic19maWxlICpmaWxlLAotCQkJICAgICAgc3RydWN0IGliX3VkYXRhICp1Y29yZSwKLQkJCSAgICAgIHN0cnVjdCBpYl91ZGF0YSAqdWh3KQotewotCXN0cnVjdCBpYl91dmVyYnNfZXhfcXVlcnlfZGV2aWNlX3Jlc3AgcmVzcDsKLQlzdHJ1Y3QgaWJfdXZlcmJzX2V4X3F1ZXJ5X2RldmljZSAgY21kOwotCXN0cnVjdCBpYl9kZXZpY2VfYXR0ciBhdHRyOwotCXN0cnVjdCBpYl9kZXZpY2UgKmRldmljZTsKLQlpbnQgZXJyOwotCi0JZGV2aWNlID0gZmlsZS0+ZGV2aWNlLT5pYl9kZXY7Ci0JaWYgKHVjb3JlLT5pbmxlbiA8IHNpemVvZihjbWQpKQotCQlyZXR1cm4gLUVJTlZBTDsKLQotCWVyciA9IGliX2NvcHlfZnJvbV91ZGF0YSgmY21kLCB1Y29yZSwgc2l6ZW9mKGNtZCkpOwotCWlmIChlcnIpCi0JCXJldHVybiBlcnI7Ci0KLQlpZiAoY21kLnJlc2VydmVkKQotCQlyZXR1cm4gLUVJTlZBTDsKLQotCWVyciA9IGRldmljZS0+cXVlcnlfZGV2aWNlKGRldmljZSwgJmF0dHIpOwotCWlmIChlcnIpCi0JCXJldHVybiBlcnI7Ci0KLQltZW1zZXQoJnJlc3AsIDAsIHNpemVvZihyZXNwKSk7Ci0JY29weV9xdWVyeV9kZXZfZmllbGRzKGZpbGUsICZyZXNwLmJhc2UsICZhdHRyKTsKLQlyZXNwLmNvbXBfbWFzayA9IDA7Ci0KLSNpZmRlZiBDT05GSUdfSU5GSU5JQkFORF9PTl9ERU1BTkRfUEFHSU5HCi0JaWYgKGNtZC5jb21wX21hc2sgJiBJQl9VU0VSX1ZFUkJTX0VYX1FVRVJZX0RFVklDRV9PRFApIHsKLQkJcmVzcC5vZHBfY2Fwcy5nZW5lcmFsX2NhcHMgPSBhdHRyLm9kcF9jYXBzLmdlbmVyYWxfY2FwczsKLQkJcmVzcC5vZHBfY2Fwcy5wZXJfdHJhbnNwb3J0X2NhcHMucmNfb2RwX2NhcHMgPQotCQkJYXR0ci5vZHBfY2Fwcy5wZXJfdHJhbnNwb3J0X2NhcHMucmNfb2RwX2NhcHM7Ci0JCXJlc3Aub2RwX2NhcHMucGVyX3RyYW5zcG9ydF9jYXBzLnVjX29kcF9jYXBzID0KLQkJCWF0dHIub2RwX2NhcHMucGVyX3RyYW5zcG9ydF9jYXBzLnVjX29kcF9jYXBzOwotCQlyZXNwLm9kcF9jYXBzLnBlcl90cmFuc3BvcnRfY2Fwcy51ZF9vZHBfY2FwcyA9Ci0JCQlhdHRyLm9kcF9jYXBzLnBlcl90cmFuc3BvcnRfY2Fwcy51ZF9vZHBfY2FwczsKLQkJcmVzcC5jb21wX21hc2sgfD0gSUJfVVNFUl9WRVJCU19FWF9RVUVSWV9ERVZJQ0VfT0RQOwotCX0KLSNlbmRpZgotCi0JZXJyID0gaWJfY29weV90b191ZGF0YSh1Y29yZSwgJnJlc3AsIHNpemVvZihyZXNwKSk7Ci0JaWYgKGVycikKLQkJcmV0dXJuIGVycjsKLQotCXJldHVybiAwOwotfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL2NvcmUvdXZlcmJzX21haW4uYyBiL2RyaXZlcnMvaW5maW5pYmFuZC9jb3JlL3V2ZXJic19tYWluLmMKaW5kZXggZTZjMjNiOS4uNWRiMWE4YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbmZpbmliYW5kL2NvcmUvdXZlcmJzX21haW4uYworKysgYi9kcml2ZXJzL2luZmluaWJhbmQvY29yZS91dmVyYnNfbWFpbi5jCkBAIC0xMjMsNyArMTIzLDYgQEAKIAkJCQkgICAgc3RydWN0IGliX3VkYXRhICp1aHcpID0gewogCVtJQl9VU0VSX1ZFUkJTX0VYX0NNRF9DUkVBVEVfRkxPV10JPSBpYl91dmVyYnNfZXhfY3JlYXRlX2Zsb3csCiAJW0lCX1VTRVJfVkVSQlNfRVhfQ01EX0RFU1RST1lfRkxPV10JPSBpYl91dmVyYnNfZXhfZGVzdHJveV9mbG93LAotCVtJQl9VU0VSX1ZFUkJTX0VYX0NNRF9RVUVSWV9ERVZJQ0VdCT0gaWJfdXZlcmJzX2V4X3F1ZXJ5X2RldmljZQogfTsKIAogc3RhdGljIHZvaWQgaWJfdXZlcmJzX2FkZF9vbmUoc3RydWN0IGliX2RldmljZSAqZGV2aWNlKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9tbHg0L21haW4uYyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9tbHg0L21haW4uYwppbmRleCA1N2VjYzViLi45MTE3YjdhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvbWx4NC9tYWluLmMKKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L21seDQvbWFpbi5jCkBAIC0xMTE0LDcgKzExMTQsOCBAQAogCXN0cnVjdCBtbHg0X2RldgkqZGV2ID0gdG9fbWRldihxcC0+ZGV2aWNlKS0+ZGV2OwogCWludCBlcnIgPSAwOwogCi0JaWYgKGRldi0+Y2Fwcy50dW5uZWxfb2ZmbG9hZF9tb2RlICE9IE1MWDRfVFVOTkVMX09GRkxPQURfTU9ERV9WWExBTikKKwlpZiAoZGV2LT5jYXBzLnR1bm5lbF9vZmZsb2FkX21vZGUgIT0gTUxYNF9UVU5ORUxfT0ZGTE9BRF9NT0RFX1ZYTEFOIHx8CisJICAgIGRldi0+Y2Fwcy5kbWZzX2hpZ2hfc3RlZXJfbW9kZSA9PSBNTFg0X1NURUVSSU5HX0RNRlNfQTBfU1RBVElDKQogCQlyZXR1cm4gMDsgLyogZG8gbm90aGluZyAqLwogCiAJaWJfZmxvdyA9IGZsb3dfYXR0ciArIDE7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvbWx4NS9tYWluLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvbWx4NS9tYWluLmMKaW5kZXggOGE4NzQwNC4uMDNiZjgxMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L21seDUvbWFpbi5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9tbHg1L21haW4uYwpAQCAtMTMzMSw4ICsxMzMxLDYgQEAKIAkJKDF1bGwgPDwgSUJfVVNFUl9WRVJCU19DTURfREVTVFJPWV9TUlEpCQl8CiAJCSgxdWxsIDw8IElCX1VTRVJfVkVSQlNfQ01EX0NSRUFURV9YU1JRKQkJfAogCQkoMXVsbCA8PCBJQl9VU0VSX1ZFUkJTX0NNRF9PUEVOX1FQKTsKLQlkZXYtPmliX2Rldi51dmVyYnNfZXhfY21kX21hc2sgPQotCQkoMXVsbCA8PCBJQl9VU0VSX1ZFUkJTX0VYX0NNRF9RVUVSWV9ERVZJQ0UpOwogCiAJZGV2LT5pYl9kZXYucXVlcnlfZGV2aWNlCT0gbWx4NV9pYl9xdWVyeV9kZXZpY2U7CiAJZGV2LT5pYl9kZXYucXVlcnlfcG9ydAkJPSBtbHg1X2liX3F1ZXJ5X3BvcnQ7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvdWxwL2lwb2liL2lwb2liLmggYi9kcml2ZXJzL2luZmluaWJhbmQvdWxwL2lwb2liL2lwb2liLmgKaW5kZXggOGJhODBhNi4uZDc1NjJiZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbmZpbmliYW5kL3VscC9pcG9pYi9pcG9pYi5oCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC91bHAvaXBvaWIvaXBvaWIuaApAQCAtOTgsMTUgKzk4LDkgQEAKIAogCUlQT0lCX01DQVNUX0ZMQUdfRk9VTkQJICA9IDAsCS8qIHVzZWQgaW4gc2V0X211bHRpY2FzdF9saXN0ICovCiAJSVBPSUJfTUNBU1RfRkxBR19TRU5ET05MWSA9IDEsCi0JLyoKLQkgKiBGb3IgSVBPSUJfTUNBU1RfRkxBR19CVVNZCi0JICogV2hlbiBzZXQsIGluIGZsaWdodCBqb2luIGFuZCBtY2FzdC0+bWMgaXMgdW5yZWxpYWJsZQotCSAqIFdoZW4gY2xlYXIgYW5kIG1jYXN0LT5tYyBJU19FUlJfT1JfTlVMTCwgbmVlZCB0byByZXN0YXJ0IG9yCi0JICogICBoYXZlbid0IHN0YXJ0ZWQgeWV0Ci0JICogV2hlbiBjbGVhciBhbmQgbWNhc3QtPm1jIGlzIHZhbGlkIHBvaW50ZXIsIGpvaW4gd2FzIHN1Y2Nlc3NmdWwKLQkgKi8KLQlJUE9JQl9NQ0FTVF9GTEFHX0JVU1kJICA9IDIsCisJSVBPSUJfTUNBU1RfRkxBR19CVVNZCSAgPSAyLAkvKiBqb2luaW5nIG9yIGFscmVhZHkgam9pbmVkICovCiAJSVBPSUJfTUNBU1RfRkxBR19BVFRBQ0hFRCA9IDMsCisJSVBPSUJfTUNBU1RfSk9JTl9TVEFSVEVEICA9IDQsCiAKIAlNQVhfU0VORF9DUUUJCSAgPSAxNiwKIAlJUE9JQl9DTV9DT1BZQlJFQUsJICA9IDI1NiwKQEAgLTMyMyw3ICszMTcsNiBAQAogCXN0cnVjdCBsaXN0X2hlYWQgbXVsdGljYXN0X2xpc3Q7CiAJc3RydWN0IHJiX3Jvb3QgbXVsdGljYXN0X3RyZWU7CiAKLQlzdHJ1Y3Qgd29ya3F1ZXVlX3N0cnVjdCAqd3E7CiAJc3RydWN0IGRlbGF5ZWRfd29yayBtY2FzdF90YXNrOwogCXN0cnVjdCB3b3JrX3N0cnVjdCBjYXJyaWVyX29uX3Rhc2s7CiAJc3RydWN0IHdvcmtfc3RydWN0IGZsdXNoX2xpZ2h0OwpAQCAtNDg0LDEwICs0NzcsMTAgQEAKIHZvaWQgaXBvaWJfcGtleV9ldmVudChzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspOwogdm9pZCBpcG9pYl9pYl9kZXZfY2xlYW51cChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KTsKIAotaW50IGlwb2liX2liX2Rldl9vcGVuKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpOworaW50IGlwb2liX2liX2Rldl9vcGVuKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsIGludCBmbHVzaCk7CiBpbnQgaXBvaWJfaWJfZGV2X3VwKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpOwotaW50IGlwb2liX2liX2Rldl9kb3duKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpOwotaW50IGlwb2liX2liX2Rldl9zdG9wKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpOworaW50IGlwb2liX2liX2Rldl9kb3duKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsIGludCBmbHVzaCk7CitpbnQgaXBvaWJfaWJfZGV2X3N0b3Aoc3RydWN0IG5ldF9kZXZpY2UgKmRldiwgaW50IGZsdXNoKTsKIHZvaWQgaXBvaWJfcGtleV9kZXZfY2hlY2tfcHJlc2VuY2Uoc3RydWN0IG5ldF9kZXZpY2UgKmRldik7CiAKIGludCBpcG9pYl9kZXZfaW5pdChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LCBzdHJ1Y3QgaWJfZGV2aWNlICpjYSwgaW50IHBvcnQpOwpAQCAtNDk5LDcgKzQ5Miw3IEBACiAKIHZvaWQgaXBvaWJfbWNhc3RfcmVzdGFydF90YXNrKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yayk7CiBpbnQgaXBvaWJfbWNhc3Rfc3RhcnRfdGhyZWFkKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpOwotaW50IGlwb2liX21jYXN0X3N0b3BfdGhyZWFkKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpOworaW50IGlwb2liX21jYXN0X3N0b3BfdGhyZWFkKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsIGludCBmbHVzaCk7CiAKIHZvaWQgaXBvaWJfbWNhc3RfZGV2X2Rvd24oc3RydWN0IG5ldF9kZXZpY2UgKmRldik7CiB2b2lkIGlwb2liX21jYXN0X2Rldl9mbHVzaChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5maW5pYmFuZC91bHAvaXBvaWIvaXBvaWJfY20uYyBiL2RyaXZlcnMvaW5maW5pYmFuZC91bHAvaXBvaWIvaXBvaWJfY20uYwppbmRleCA1Njk1OWFkLi45MzNlZmNlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvdWxwL2lwb2liL2lwb2liX2NtLmMKKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL3VscC9pcG9pYi9pcG9pYl9jbS5jCkBAIC00NzQsNyArNDc0LDcgQEAKIAl9CiAKIAlzcGluX2xvY2tfaXJxKCZwcml2LT5sb2NrKTsKLQlxdWV1ZV9kZWxheWVkX3dvcmsocHJpdi0+d3EsCisJcXVldWVfZGVsYXllZF93b3JrKGlwb2liX3dvcmtxdWV1ZSwKIAkJCSAgICZwcml2LT5jbS5zdGFsZV90YXNrLCBJUE9JQl9DTV9SWF9ERUxBWSk7CiAJLyogQWRkIHRoaXMgZW50cnkgdG8gcGFzc2l2ZSBpZHMgbGlzdCBoZWFkLCBidXQgZG8gbm90IHJlLWFkZCBpdAogCSAqIGlmIElCX0VWRU5UX1FQX0xBU1RfV1FFX1JFQUNIRUQgaGFzIG1vdmVkIGl0IHRvIGZsdXNoIGxpc3QuICovCkBAIC01NzYsNyArNTc2LDcgQEAKIAkJCXNwaW5fbG9ja19pcnFzYXZlKCZwcml2LT5sb2NrLCBmbGFncyk7CiAJCQlsaXN0X3NwbGljZV9pbml0KCZwcml2LT5jbS5yeF9kcmFpbl9saXN0LCAmcHJpdi0+Y20ucnhfcmVhcF9saXN0KTsKIAkJCWlwb2liX2NtX3N0YXJ0X3J4X2RyYWluKHByaXYpOwotCQkJcXVldWVfd29yayhwcml2LT53cSwgJnByaXYtPmNtLnJ4X3JlYXBfdGFzayk7CisJCQlxdWV1ZV93b3JrKGlwb2liX3dvcmtxdWV1ZSwgJnByaXYtPmNtLnJ4X3JlYXBfdGFzayk7CiAJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT5sb2NrLCBmbGFncyk7CiAJCX0gZWxzZQogCQkJaXBvaWJfd2Fybihwcml2LCAiY20gcmVjdiBjb21wbGV0aW9uIGV2ZW50IHdpdGggd3JpZCAlZCAoPiAlZClcbiIsCkBAIC02MDMsNyArNjAzLDcgQEAKIAkJCQlzcGluX2xvY2tfaXJxc2F2ZSgmcHJpdi0+bG9jaywgZmxhZ3MpOwogCQkJCWxpc3RfbW92ZSgmcC0+bGlzdCwgJnByaXYtPmNtLnJ4X3JlYXBfbGlzdCk7CiAJCQkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcHJpdi0+bG9jaywgZmxhZ3MpOwotCQkJCXF1ZXVlX3dvcmsocHJpdi0+d3EsICZwcml2LT5jbS5yeF9yZWFwX3Rhc2spOworCQkJCXF1ZXVlX3dvcmsoaXBvaWJfd29ya3F1ZXVlLCAmcHJpdi0+Y20ucnhfcmVhcF90YXNrKTsKIAkJCX0KIAkJCXJldHVybjsKIAkJfQpAQCAtODI3LDcgKzgyNyw3IEBACiAKIAkJaWYgKHRlc3RfYW5kX2NsZWFyX2JpdChJUE9JQl9GTEFHX0lOSVRJQUxJWkVELCAmdHgtPmZsYWdzKSkgewogCQkJbGlzdF9tb3ZlKCZ0eC0+bGlzdCwgJnByaXYtPmNtLnJlYXBfbGlzdCk7Ci0JCQlxdWV1ZV93b3JrKHByaXYtPndxLCAmcHJpdi0+Y20ucmVhcF90YXNrKTsKKwkJCXF1ZXVlX3dvcmsoaXBvaWJfd29ya3F1ZXVlLCAmcHJpdi0+Y20ucmVhcF90YXNrKTsKIAkJfQogCiAJCWNsZWFyX2JpdChJUE9JQl9GTEFHX09QRVJfVVAsICZ0eC0+ZmxhZ3MpOwpAQCAtMTI1NSw3ICsxMjU1LDcgQEAKIAogCQlpZiAodGVzdF9hbmRfY2xlYXJfYml0KElQT0lCX0ZMQUdfSU5JVElBTElaRUQsICZ0eC0+ZmxhZ3MpKSB7CiAJCQlsaXN0X21vdmUoJnR4LT5saXN0LCAmcHJpdi0+Y20ucmVhcF9saXN0KTsKLQkJCXF1ZXVlX3dvcmsocHJpdi0+d3EsICZwcml2LT5jbS5yZWFwX3Rhc2spOworCQkJcXVldWVfd29yayhpcG9pYl93b3JrcXVldWUsICZwcml2LT5jbS5yZWFwX3Rhc2spOwogCQl9CiAKIAkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcHJpdi0+bG9jaywgZmxhZ3MpOwpAQCAtMTI4NCw3ICsxMjg0LDcgQEAKIAl0eC0+ZGV2ID0gZGV2OwogCWxpc3RfYWRkKCZ0eC0+bGlzdCwgJnByaXYtPmNtLnN0YXJ0X2xpc3QpOwogCXNldF9iaXQoSVBPSUJfRkxBR19JTklUSUFMSVpFRCwgJnR4LT5mbGFncyk7Ci0JcXVldWVfd29yayhwcml2LT53cSwgJnByaXYtPmNtLnN0YXJ0X3Rhc2spOworCXF1ZXVlX3dvcmsoaXBvaWJfd29ya3F1ZXVlLCAmcHJpdi0+Y20uc3RhcnRfdGFzayk7CiAJcmV0dXJuIHR4OwogfQogCkBAIC0xMjk1LDcgKzEyOTUsNyBAQAogCWlmICh0ZXN0X2FuZF9jbGVhcl9iaXQoSVBPSUJfRkxBR19JTklUSUFMSVpFRCwgJnR4LT5mbGFncykpIHsKIAkJc3Bpbl9sb2NrX2lycXNhdmUoJnByaXYtPmxvY2ssIGZsYWdzKTsKIAkJbGlzdF9tb3ZlKCZ0eC0+bGlzdCwgJnByaXYtPmNtLnJlYXBfbGlzdCk7Ci0JCXF1ZXVlX3dvcmsocHJpdi0+d3EsICZwcml2LT5jbS5yZWFwX3Rhc2spOworCQlxdWV1ZV93b3JrKGlwb2liX3dvcmtxdWV1ZSwgJnByaXYtPmNtLnJlYXBfdGFzayk7CiAJCWlwb2liX2RiZyhwcml2LCAiUmVhcCBjb25uZWN0aW9uIGZvciBnaWQgJXBJNlxuIiwKIAkJCSAgdHgtPm5laWdoLT5kYWRkciArIDQpOwogCQl0eC0+bmVpZ2ggPSBOVUxMOwpAQCAtMTQxNyw3ICsxNDE3LDcgQEAKIAogCXNrYl9xdWV1ZV90YWlsKCZwcml2LT5jbS5za2JfcXVldWUsIHNrYik7CiAJaWYgKGUpCi0JCXF1ZXVlX3dvcmsocHJpdi0+d3EsICZwcml2LT5jbS5za2JfdGFzayk7CisJCXF1ZXVlX3dvcmsoaXBvaWJfd29ya3F1ZXVlLCAmcHJpdi0+Y20uc2tiX3Rhc2spOwogfQogCiBzdGF0aWMgdm9pZCBpcG9pYl9jbV9yeF9yZWFwKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yaykKQEAgLTE0NTAsNyArMTQ1MCw3IEBACiAJfQogCiAJaWYgKCFsaXN0X2VtcHR5KCZwcml2LT5jbS5wYXNzaXZlX2lkcykpCi0JCXF1ZXVlX2RlbGF5ZWRfd29yayhwcml2LT53cSwKKwkJcXVldWVfZGVsYXllZF93b3JrKGlwb2liX3dvcmtxdWV1ZSwKIAkJCQkgICAmcHJpdi0+Y20uc3RhbGVfdGFzaywgSVBPSUJfQ01fUlhfREVMQVkpOwogCXNwaW5fdW5sb2NrX2lycSgmcHJpdi0+bG9jayk7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvdWxwL2lwb2liL2lwb2liX2liLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvdWxwL2lwb2liL2lwb2liX2liLmMKaW5kZXggZmU2NWFiYi4uNzI2MjZjMzQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC91bHAvaXBvaWIvaXBvaWJfaWIuYworKysgYi9kcml2ZXJzL2luZmluaWJhbmQvdWxwL2lwb2liL2lwb2liX2liLmMKQEAgLTY1NSw3ICs2NTUsNyBAQAogCV9faXBvaWJfcmVhcF9haChkZXYpOwogCiAJaWYgKCF0ZXN0X2JpdChJUE9JQl9TVE9QX1JFQVBFUiwgJnByaXYtPmZsYWdzKSkKLQkJcXVldWVfZGVsYXllZF93b3JrKHByaXYtPndxLCAmcHJpdi0+YWhfcmVhcF90YXNrLAorCQlxdWV1ZV9kZWxheWVkX3dvcmsoaXBvaWJfd29ya3F1ZXVlLCAmcHJpdi0+YWhfcmVhcF90YXNrLAogCQkJCSAgIHJvdW5kX2ppZmZpZXNfcmVsYXRpdmUoSFopKTsKIH0KIApAQCAtNjY0LDcgKzY2NCw3IEBACiAJZHJhaW5fdHhfY3EoKHN0cnVjdCBuZXRfZGV2aWNlICopY3R4KTsKIH0KIAotaW50IGlwb2liX2liX2Rldl9vcGVuKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCitpbnQgaXBvaWJfaWJfZGV2X29wZW4oc3RydWN0IG5ldF9kZXZpY2UgKmRldiwgaW50IGZsdXNoKQogewogCXN0cnVjdCBpcG9pYl9kZXZfcHJpdiAqcHJpdiA9IG5ldGRldl9wcml2KGRldik7CiAJaW50IHJldDsKQEAgLTY5Niw3ICs2OTYsNyBAQAogCX0KIAogCWNsZWFyX2JpdChJUE9JQl9TVE9QX1JFQVBFUiwgJnByaXYtPmZsYWdzKTsKLQlxdWV1ZV9kZWxheWVkX3dvcmsocHJpdi0+d3EsICZwcml2LT5haF9yZWFwX3Rhc2ssCisJcXVldWVfZGVsYXllZF93b3JrKGlwb2liX3dvcmtxdWV1ZSwgJnByaXYtPmFoX3JlYXBfdGFzaywKIAkJCSAgIHJvdW5kX2ppZmZpZXNfcmVsYXRpdmUoSFopKTsKIAogCWlmICghdGVzdF9hbmRfc2V0X2JpdChJUE9JQl9GTEFHX0lOSVRJQUxJWkVELCAmcHJpdi0+ZmxhZ3MpKQpAQCAtNzA2LDcgKzcwNiw3IEBACiBkZXZfc3RvcDoKIAlpZiAoIXRlc3RfYW5kX3NldF9iaXQoSVBPSUJfRkxBR19JTklUSUFMSVpFRCwgJnByaXYtPmZsYWdzKSkKIAkJbmFwaV9lbmFibGUoJnByaXYtPm5hcGkpOwotCWlwb2liX2liX2Rldl9zdG9wKGRldik7CisJaXBvaWJfaWJfZGV2X3N0b3AoZGV2LCBmbHVzaCk7CiAJcmV0dXJuIC0xOwogfQogCkBAIC03MzgsNyArNzM4LDcgQEAKIAlyZXR1cm4gaXBvaWJfbWNhc3Rfc3RhcnRfdGhyZWFkKGRldik7CiB9CiAKLWludCBpcG9pYl9pYl9kZXZfZG93bihzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQoraW50IGlwb2liX2liX2Rldl9kb3duKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsIGludCBmbHVzaCkKIHsKIAlzdHJ1Y3QgaXBvaWJfZGV2X3ByaXYgKnByaXYgPSBuZXRkZXZfcHJpdihkZXYpOwogCkBAIC03NDcsNyArNzQ3LDcgQEAKIAljbGVhcl9iaXQoSVBPSUJfRkxBR19PUEVSX1VQLCAmcHJpdi0+ZmxhZ3MpOwogCW5ldGlmX2NhcnJpZXJfb2ZmKGRldik7CiAKLQlpcG9pYl9tY2FzdF9zdG9wX3RocmVhZChkZXYpOworCWlwb2liX21jYXN0X3N0b3BfdGhyZWFkKGRldiwgZmx1c2gpOwogCWlwb2liX21jYXN0X2Rldl9mbHVzaChkZXYpOwogCiAJaXBvaWJfZmx1c2hfcGF0aHMoZGV2KTsKQEAgLTgwNyw3ICs4MDcsNyBAQAogCWxvY2FsX2JoX2VuYWJsZSgpOwogfQogCi1pbnQgaXBvaWJfaWJfZGV2X3N0b3Aoc3RydWN0IG5ldF9kZXZpY2UgKmRldikKK2ludCBpcG9pYl9pYl9kZXZfc3RvcChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LCBpbnQgZmx1c2gpCiB7CiAJc3RydWN0IGlwb2liX2Rldl9wcml2ICpwcml2ID0gbmV0ZGV2X3ByaXYoZGV2KTsKIAlzdHJ1Y3QgaWJfcXBfYXR0ciBxcF9hdHRyOwpAQCAtODgwLDcgKzg4MCw4IEBACiAJLyogV2FpdCBmb3IgYWxsIEFIcyB0byBiZSByZWFwZWQgKi8KIAlzZXRfYml0KElQT0lCX1NUT1BfUkVBUEVSLCAmcHJpdi0+ZmxhZ3MpOwogCWNhbmNlbF9kZWxheWVkX3dvcmsoJnByaXYtPmFoX3JlYXBfdGFzayk7Ci0JZmx1c2hfd29ya3F1ZXVlKHByaXYtPndxKTsKKwlpZiAoZmx1c2gpCisJCWZsdXNoX3dvcmtxdWV1ZShpcG9pYl93b3JrcXVldWUpOwogCiAJYmVnaW4gPSBqaWZmaWVzOwogCkBAIC05MTcsNyArOTE4LDcgQEAKIAkJICAgICh1bnNpZ25lZCBsb25nKSBkZXYpOwogCiAJaWYgKGRldi0+ZmxhZ3MgJiBJRkZfVVApIHsKLQkJaWYgKGlwb2liX2liX2Rldl9vcGVuKGRldikpIHsKKwkJaWYgKGlwb2liX2liX2Rldl9vcGVuKGRldiwgMSkpIHsKIAkJCWlwb2liX3RyYW5zcG9ydF9kZXZfY2xlYW51cChkZXYpOwogCQkJcmV0dXJuIC1FTk9ERVY7CiAJCX0KQEAgLTEwMzksMTIgKzEwNDAsMTIgQEAKIAl9CiAKIAlpZiAobGV2ZWwgPj0gSVBPSUJfRkxVU0hfTk9STUFMKQotCQlpcG9pYl9pYl9kZXZfZG93bihkZXYpOworCQlpcG9pYl9pYl9kZXZfZG93bihkZXYsIDApOwogCiAJaWYgKGxldmVsID09IElQT0lCX0ZMVVNIX0hFQVZZKSB7CiAJCWlmICh0ZXN0X2JpdChJUE9JQl9GTEFHX0lOSVRJQUxJWkVELCAmcHJpdi0+ZmxhZ3MpKQotCQkJaXBvaWJfaWJfZGV2X3N0b3AoZGV2KTsKLQkJaWYgKGlwb2liX2liX2Rldl9vcGVuKGRldikgIT0gMCkKKwkJCWlwb2liX2liX2Rldl9zdG9wKGRldiwgMCk7CisJCWlmIChpcG9pYl9pYl9kZXZfb3BlbihkZXYsIDApICE9IDApCiAJCQlyZXR1cm47CiAJCWlmIChuZXRpZl9xdWV1ZV9zdG9wcGVkKGRldikpCiAJCQluZXRpZl9zdGFydF9xdWV1ZShkZXYpOwpAQCAtMTA5Niw3ICsxMDk3LDcgQEAKIAkgKi8KIAlpcG9pYl9mbHVzaF9wYXRocyhkZXYpOwogCi0JaXBvaWJfbWNhc3Rfc3RvcF90aHJlYWQoZGV2KTsKKwlpcG9pYl9tY2FzdF9zdG9wX3RocmVhZChkZXYsIDEpOwogCWlwb2liX21jYXN0X2Rldl9mbHVzaChkZXYpOwogCiAJaXBvaWJfdHJhbnNwb3J0X2Rldl9jbGVhbnVwKGRldik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvdWxwL2lwb2liL2lwb2liX21haW4uYyBiL2RyaXZlcnMvaW5maW5pYmFuZC91bHAvaXBvaWIvaXBvaWJfbWFpbi5jCmluZGV4IDZiYWQxN2QuLjU4YjVhYTMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC91bHAvaXBvaWIvaXBvaWJfbWFpbi5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC91bHAvaXBvaWIvaXBvaWJfbWFpbi5jCkBAIC0xMDgsNyArMTA4LDcgQEAKIAogCXNldF9iaXQoSVBPSUJfRkxBR19BRE1JTl9VUCwgJnByaXYtPmZsYWdzKTsKIAotCWlmIChpcG9pYl9pYl9kZXZfb3BlbihkZXYpKSB7CisJaWYgKGlwb2liX2liX2Rldl9vcGVuKGRldiwgMSkpIHsKIAkJaWYgKCF0ZXN0X2JpdChJUE9JQl9QS0VZX0FTU0lHTkVELCAmcHJpdi0+ZmxhZ3MpKQogCQkJcmV0dXJuIDA7CiAJCWdvdG8gZXJyX2Rpc2FibGU7CkBAIC0xMzksNyArMTM5LDcgQEAKIAlyZXR1cm4gMDsKIAogZXJyX3N0b3A6Ci0JaXBvaWJfaWJfZGV2X3N0b3AoZGV2KTsKKwlpcG9pYl9pYl9kZXZfc3RvcChkZXYsIDEpOwogCiBlcnJfZGlzYWJsZToKIAljbGVhcl9iaXQoSVBPSUJfRkxBR19BRE1JTl9VUCwgJnByaXYtPmZsYWdzKTsKQEAgLTE1Nyw4ICsxNTcsOCBAQAogCiAJbmV0aWZfc3RvcF9xdWV1ZShkZXYpOwogCi0JaXBvaWJfaWJfZGV2X2Rvd24oZGV2KTsKLQlpcG9pYl9pYl9kZXZfc3RvcChkZXYpOworCWlwb2liX2liX2Rldl9kb3duKGRldiwgMSk7CisJaXBvaWJfaWJfZGV2X3N0b3AoZGV2LCAwKTsKIAogCWlmICghdGVzdF9iaXQoSVBPSUJfRkxBR19TVUJJTlRFUkZBQ0UsICZwcml2LT5mbGFncykpIHsKIAkJc3RydWN0IGlwb2liX2Rldl9wcml2ICpjcHJpdjsKQEAgLTgzOSw3ICs4MzksNyBAQAogCQlyZXR1cm47CiAJfQogCi0JcXVldWVfd29yayhwcml2LT53cSwgJnByaXYtPnJlc3RhcnRfdGFzayk7CisJcXVldWVfd29yayhpcG9pYl93b3JrcXVldWUsICZwcml2LT5yZXN0YXJ0X3Rhc2spOwogfQogCiBzdGF0aWMgdTMyIGlwb2liX2FkZHJfaGFzaChzdHJ1Y3QgaXBvaWJfbmVpZ2hfaGFzaCAqaHRibCwgdTggKmRhZGRyKQpAQCAtOTU0LDcgKzk1NCw3IEBACiAJX19pcG9pYl9yZWFwX25laWdoKHByaXYpOwogCiAJaWYgKCF0ZXN0X2JpdChJUE9JQl9TVE9QX05FSUdIX0dDLCAmcHJpdi0+ZmxhZ3MpKQotCQlxdWV1ZV9kZWxheWVkX3dvcmsocHJpdi0+d3EsICZwcml2LT5uZWlnaF9yZWFwX3Rhc2ssCisJCXF1ZXVlX2RlbGF5ZWRfd29yayhpcG9pYl93b3JrcXVldWUsICZwcml2LT5uZWlnaF9yZWFwX3Rhc2ssCiAJCQkJICAgYXJwX3RibC5nY19pbnRlcnZhbCk7CiB9CiAKQEAgLTExMzMsNyArMTEzMyw3IEBACiAKIAkvKiBzdGFydCBnYXJiYWdlIGNvbGxlY3Rpb24gKi8KIAljbGVhcl9iaXQoSVBPSUJfU1RPUF9ORUlHSF9HQywgJnByaXYtPmZsYWdzKTsKLQlxdWV1ZV9kZWxheWVkX3dvcmsocHJpdi0+d3EsICZwcml2LT5uZWlnaF9yZWFwX3Rhc2ssCisJcXVldWVfZGVsYXllZF93b3JrKGlwb2liX3dvcmtxdWV1ZSwgJnByaXYtPm5laWdoX3JlYXBfdGFzaywKIAkJCSAgIGFycF90YmwuZ2NfaW50ZXJ2YWwpOwogCiAJcmV0dXJuIDA7CkBAIC0xMjYyLDEzICsxMjYyLDE1IEBACiB7CiAJc3RydWN0IGlwb2liX2Rldl9wcml2ICpwcml2ID0gbmV0ZGV2X3ByaXYoZGV2KTsKIAorCWlmIChpcG9pYl9uZWlnaF9oYXNoX2luaXQocHJpdikgPCAwKQorCQlnb3RvIG91dDsKIAkvKiBBbGxvY2F0ZSBSWC9UWCAicmluZ3MiIHRvIGhvbGQgcXVldWVkIHNrYnMgKi8KIAlwcml2LT5yeF9yaW5nID0Ja3phbGxvYyhpcG9pYl9yZWN2cV9zaXplICogc2l6ZW9mICpwcml2LT5yeF9yaW5nLAogCQkJCUdGUF9LRVJORUwpOwogCWlmICghcHJpdi0+cnhfcmluZykgewogCQlwcmludGsoS0VSTl9XQVJOSU5HICIlczogZmFpbGVkIHRvIGFsbG9jYXRlIFJYIHJpbmcgKCVkIGVudHJpZXMpXG4iLAogCQkgICAgICAgY2EtPm5hbWUsIGlwb2liX3JlY3ZxX3NpemUpOwotCQlnb3RvIG91dDsKKwkJZ290byBvdXRfbmVpZ2hfaGFzaF9jbGVhbnVwOwogCX0KIAogCXByaXYtPnR4X3JpbmcgPSB2emFsbG9jKGlwb2liX3NlbmRxX3NpemUgKiBzaXplb2YgKnByaXYtPnR4X3JpbmcpOwpAQCAtMTI4MywyNCArMTI4NSwxNiBAQAogCWlmIChpcG9pYl9pYl9kZXZfaW5pdChkZXYsIGNhLCBwb3J0KSkKIAkJZ290byBvdXRfdHhfcmluZ19jbGVhbnVwOwogCi0JLyoKLQkgKiBNdXN0IGJlIGFmdGVyIGlwb2liX2liX2Rldl9pbml0IHNvIHdlIGNhbiBhbGxvY2F0ZSBhIHBlcgotCSAqIGRldmljZSB3cSB0aGVyZSBhbmQgdXNlIGl0IGhlcmUKLQkgKi8KLQlpZiAoaXBvaWJfbmVpZ2hfaGFzaF9pbml0KHByaXYpIDwgMCkKLQkJZ290byBvdXRfZGV2X3VuaW5pdDsKLQogCXJldHVybiAwOwogCi1vdXRfZGV2X3VuaW5pdDoKLQlpcG9pYl9pYl9kZXZfY2xlYW51cChkZXYpOwotCiBvdXRfdHhfcmluZ19jbGVhbnVwOgogCXZmcmVlKHByaXYtPnR4X3JpbmcpOwogCiBvdXRfcnhfcmluZ19jbGVhbnVwOgogCWtmcmVlKHByaXYtPnJ4X3JpbmcpOwogCitvdXRfbmVpZ2hfaGFzaF9jbGVhbnVwOgorCWlwb2liX25laWdoX2hhc2hfdW5pbml0KGRldik7CiBvdXQ6CiAJcmV0dXJuIC1FTk9NRU07CiB9CkBAIC0xMzIzLDEyICsxMzE3LDYgQEAKIAl9CiAJdW5yZWdpc3Rlcl9uZXRkZXZpY2VfbWFueSgmaGVhZCk7CiAKLQkvKgotCSAqIE11c3QgYmUgYmVmb3JlIGlwb2liX2liX2Rldl9jbGVhbnVwIG9yIHdlIGRlbGV0ZSBhbiBpbiB1c2UKLQkgKiB3b3JrIHF1ZXVlCi0JICovCi0JaXBvaWJfbmVpZ2hfaGFzaF91bmluaXQoZGV2KTsKLQogCWlwb2liX2liX2Rldl9jbGVhbnVwKGRldik7CiAKIAlrZnJlZShwcml2LT5yeF9yaW5nKTsKQEAgLTEzMzYsNiArMTMyNCw4IEBACiAKIAlwcml2LT5yeF9yaW5nID0gTlVMTDsKIAlwcml2LT50eF9yaW5nID0gTlVMTDsKKworCWlwb2liX25laWdoX2hhc2hfdW5pbml0KGRldik7CiB9CiAKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgaGVhZGVyX29wcyBpcG9pYl9oZWFkZXJfb3BzID0gewpAQCAtMTY0Niw3ICsxNjM2LDcgQEAKIAkvKiBTdG9wIEdDIGlmIHN0YXJ0ZWQgYmVmb3JlIGZsdXNoICovCiAJc2V0X2JpdChJUE9JQl9TVE9QX05FSUdIX0dDLCAmcHJpdi0+ZmxhZ3MpOwogCWNhbmNlbF9kZWxheWVkX3dvcmsoJnByaXYtPm5laWdoX3JlYXBfdGFzayk7Ci0JZmx1c2hfd29ya3F1ZXVlKHByaXYtPndxKTsKKwlmbHVzaF93b3JrcXVldWUoaXBvaWJfd29ya3F1ZXVlKTsKIAogZXZlbnRfZmFpbGVkOgogCWlwb2liX2Rldl9jbGVhbnVwKHByaXYtPmRldik7CkBAIC0xNzE3LDcgKzE3MDcsNyBAQAogCQkvKiBTdG9wIEdDICovCiAJCXNldF9iaXQoSVBPSUJfU1RPUF9ORUlHSF9HQywgJnByaXYtPmZsYWdzKTsKIAkJY2FuY2VsX2RlbGF5ZWRfd29yaygmcHJpdi0+bmVpZ2hfcmVhcF90YXNrKTsKLQkJZmx1c2hfd29ya3F1ZXVlKHByaXYtPndxKTsKKwkJZmx1c2hfd29ya3F1ZXVlKGlwb2liX3dvcmtxdWV1ZSk7CiAKIAkJdW5yZWdpc3Rlcl9uZXRkZXYocHJpdi0+ZGV2KTsKIAkJZnJlZV9uZXRkZXYocHJpdi0+ZGV2KTsKQEAgLTE3NTgsMTMgKzE3NDgsOCBAQAogCSAqIHVucmVnaXN0ZXJfbmV0ZGV2KCkgYW5kIGxpbmt3YXRjaF9ldmVudCB0YWtlIHRoZSBydG5sIGxvY2ssCiAJICogc28gZmx1c2hfc2NoZWR1bGVkX3dvcmsoKSBjYW4gZGVhZGxvY2sgZHVyaW5nIGRldmljZQogCSAqIHJlbW92YWwuCi0JICoKLQkgKiBJbiBhZGRpdGlvbiwgYnJpbmdpbmcgb25lIGRldmljZSB1cCBhbmQgYW5vdGhlciBkb3duIGF0IHRoZQotCSAqIHNhbWUgdGltZSBjYW4gZGVhZGxvY2sgYSBzaW5nbGUgd29ya3F1ZXVlLCBzbyB3ZSBoYXZlIHRoaXMKLQkgKiBnbG9iYWwgZmFsbGJhY2sgd29ya3F1ZXVlLCBidXQgd2UgYWxzbyBhdHRlbXB0IHRvIG9wZW4gYQotCSAqIHBlciBkZXZpY2Ugd29ya3F1ZXVlIGVhY2ggdGltZSB3ZSBicmluZyBhbiBpbnRlcmZhY2UgdXAKIAkgKi8KLQlpcG9pYl93b3JrcXVldWUgPSBjcmVhdGVfc2luZ2xldGhyZWFkX3dvcmtxdWV1ZSgiaXBvaWJfZmx1c2giKTsKKwlpcG9pYl93b3JrcXVldWUgPSBjcmVhdGVfc2luZ2xldGhyZWFkX3dvcmtxdWV1ZSgiaXBvaWIiKTsKIAlpZiAoIWlwb2liX3dvcmtxdWV1ZSkgewogCQlyZXQgPSAtRU5PTUVNOwogCQlnb3RvIGVycl9mczsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5maW5pYmFuZC91bHAvaXBvaWIvaXBvaWJfbXVsdGljYXN0LmMgYi9kcml2ZXJzL2luZmluaWJhbmQvdWxwL2lwb2liL2lwb2liX211bHRpY2FzdC5jCmluZGV4IGJjNTBkZDAuLmZmYjgzYjUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC91bHAvaXBvaWIvaXBvaWJfbXVsdGljYXN0LmMKKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL3VscC9pcG9pYi9pcG9pYl9tdWx0aWNhc3QuYwpAQCAtMTkwLDYgKzE5MCwxMiBAQAogCQlzcGluX3VubG9ja19pcnEoJnByaXYtPmxvY2spOwogCQlwcml2LT50eF93ci53ci51ZC5yZW1vdGVfcWtleSA9IHByaXYtPnFrZXk7CiAJCXNldF9xa2V5ID0gMTsKKworCQlpZiAoIWlwb2liX2NtX2FkbWluX2VuYWJsZWQoZGV2KSkgeworCQkJcnRubF9sb2NrKCk7CisJCQlkZXZfc2V0X210dShkZXYsIG1pbihwcml2LT5tY2FzdF9tdHUsIHByaXYtPmFkbWluX210dSkpOworCQkJcnRubF91bmxvY2soKTsKKwkJfQogCX0KIAogCWlmICghdGVzdF9iaXQoSVBPSUJfTUNBU1RfRkxBR19TRU5ET05MWSwgJm1jYXN0LT5mbGFncykpIHsKQEAgLTI3MSwyNyArMjc3LDE2IEBACiAJc3RydWN0IGlwb2liX21jYXN0ICptY2FzdCA9IG11bHRpY2FzdC0+Y29udGV4dDsKIAlzdHJ1Y3QgbmV0X2RldmljZSAqZGV2ID0gbWNhc3QtPmRldjsKIAotCS8qCi0JICogV2UgaGF2ZSB0byB0YWtlIHRoZSBtdXRleCB0byBmb3JjZSBtY2FzdF9zZW5kb25seV9qb2luIHRvCi0JICogcmV0dXJuIGZyb20gaWJfc2FfbXVsdGljYXN0X2pvaW4gYW5kIHNldCBtY2FzdC0+bWMgdG8gYQotCSAqIHZhbGlkIHZhbHVlLiAgT3RoZXJ3aXNlIHdlIHdlcmUgcmFjaW5nIHdpdGggb3Vyc2VsdmVzIGluCi0JICogdGhhdCB3ZSBtaWdodCBmYWlsIGhlcmUsIGJ1dCBnZXQgYSB2YWxpZCByZXR1cm4gZnJvbQotCSAqIGliX3NhX211bHRpY2FzdF9qb2luIGFmdGVyIHdlIGhhZCBjbGVhcmVkIG1jYXN0LT5tYyBoZXJlLAotCSAqIHJlc3VsdGluZyBpbiBtaXMtbWF0Y2hlZCBqb2lucyBhbmQgbGVhdmVzIGFuZCBhIGRlYWRsb2NrCi0JICovCi0JbXV0ZXhfbG9jaygmbWNhc3RfbXV0ZXgpOwotCiAJLyogV2UgdHJhcCBmb3IgcG9ydCBldmVudHMgb3Vyc2VsdmVzLiAqLwogCWlmIChzdGF0dXMgPT0gLUVORVRSRVNFVCkKLQkJZ290byBvdXQ7CisJCXJldHVybiAwOwogCiAJaWYgKCFzdGF0dXMpCiAJCXN0YXR1cyA9IGlwb2liX21jYXN0X2pvaW5fZmluaXNoKG1jYXN0LCAmbXVsdGljYXN0LT5yZWMpOwogCiAJaWYgKHN0YXR1cykgewogCQlpZiAobWNhc3QtPmxvZ2NvdW50KysgPCAyMCkKLQkJCWlwb2liX2RiZ19tY2FzdChuZXRkZXZfcHJpdihkZXYpLCAic2VuZG9ubHkgbXVsdGljYXN0ICIKLQkJCQkJImpvaW4gZmFpbGVkIGZvciAlcEk2LCBzdGF0dXMgJWRcbiIsCisJCQlpcG9pYl9kYmdfbWNhc3QobmV0ZGV2X3ByaXYoZGV2KSwgIm11bHRpY2FzdCBqb2luIGZhaWxlZCBmb3IgJXBJNiwgc3RhdHVzICVkXG4iLAogCQkJCQltY2FzdC0+bWNtZW1iZXIubWdpZC5yYXcsIHN0YXR1cyk7CiAKIAkJLyogRmx1c2ggb3V0IGFueSBxdWV1ZWQgcGFja2V0cyAqLwpAQCAtMzAxLDE1ICsyOTYsMTEgQEAKIAkJCWRldl9rZnJlZV9za2JfYW55KHNrYl9kZXF1ZXVlKCZtY2FzdC0+cGt0X3F1ZXVlKSk7CiAJCX0KIAkJbmV0aWZfdHhfdW5sb2NrX2JoKGRldik7CisKKwkJLyogQ2xlYXIgdGhlIGJ1c3kgZmxhZyBzbyB3ZSB0cnkgYWdhaW4gKi8KKwkJc3RhdHVzID0gdGVzdF9hbmRfY2xlYXJfYml0KElQT0lCX01DQVNUX0ZMQUdfQlVTWSwKKwkJCQkJICAgICZtY2FzdC0+ZmxhZ3MpOwogCX0KLW91dDoKLQljbGVhcl9iaXQoSVBPSUJfTUNBU1RfRkxBR19CVVNZLCAmbWNhc3QtPmZsYWdzKTsKLQlpZiAoc3RhdHVzKQotCQltY2FzdC0+bWMgPSBOVUxMOwotCWNvbXBsZXRlKCZtY2FzdC0+ZG9uZSk7Ci0JaWYgKHN0YXR1cyA9PSAtRU5FVFJFU0VUKQotCQlzdGF0dXMgPSAwOwotCW11dGV4X3VubG9jaygmbWNhc3RfbXV0ZXgpOwogCXJldHVybiBzdGF0dXM7CiB9CiAKQEAgLTMyNywxNCArMzE4LDEyIEBACiAJaW50IHJldCA9IDA7CiAKIAlpZiAoIXRlc3RfYml0KElQT0lCX0ZMQUdfT1BFUl9VUCwgJnByaXYtPmZsYWdzKSkgewotCQlpcG9pYl9kYmdfbWNhc3QocHJpdiwgImRldmljZSBzaHV0dGluZyBkb3duLCBubyBzZW5kb25seSAiCi0JCQkJIm11bHRpY2FzdCBqb2luc1xuIik7CisJCWlwb2liX2RiZ19tY2FzdChwcml2LCAiZGV2aWNlIHNodXR0aW5nIGRvd24sIG5vIG11bHRpY2FzdCBqb2luc1xuIik7CiAJCXJldHVybiAtRU5PREVWOwogCX0KIAotCWlmICh0ZXN0X2JpdChJUE9JQl9NQ0FTVF9GTEFHX0JVU1ksICZtY2FzdC0+ZmxhZ3MpKSB7Ci0JCWlwb2liX2RiZ19tY2FzdChwcml2LCAibXVsdGljYXN0IGVudHJ5IGJ1c3ksIHNraXBwaW5nICIKLQkJCQkic2VuZG9ubHkgam9pblxuIik7CisJaWYgKHRlc3RfYW5kX3NldF9iaXQoSVBPSUJfTUNBU1RfRkxBR19CVVNZLCAmbWNhc3QtPmZsYWdzKSkgeworCQlpcG9pYl9kYmdfbWNhc3QocHJpdiwgIm11bHRpY2FzdCBlbnRyeSBidXN5LCBza2lwcGluZ1xuIik7CiAJCXJldHVybiAtRUJVU1k7CiAJfQogCkBAIC0zNDIsOSArMzMxLDYgQEAKIAlyZWMucG9ydF9naWQgPSBwcml2LT5sb2NhbF9naWQ7CiAJcmVjLnBrZXkgICAgID0gY3B1X3RvX2JlMTYocHJpdi0+cGtleSk7CiAKLQltdXRleF9sb2NrKCZtY2FzdF9tdXRleCk7Ci0JaW5pdF9jb21wbGV0aW9uKCZtY2FzdC0+ZG9uZSk7Ci0Jc2V0X2JpdChJUE9JQl9NQ0FTVF9GTEFHX0JVU1ksICZtY2FzdC0+ZmxhZ3MpOwogCW1jYXN0LT5tYyA9IGliX3NhX2pvaW5fbXVsdGljYXN0KCZpcG9pYl9zYV9jbGllbnQsIHByaXYtPmNhLAogCQkJCQkgcHJpdi0+cG9ydCwgJnJlYywKIAkJCQkJIElCX1NBX01DTUVNQkVSX1JFQ19NR0lECXwKQEAgLTM1NywxNCArMzQzLDEyIEBACiAJaWYgKElTX0VSUihtY2FzdC0+bWMpKSB7CiAJCXJldCA9IFBUUl9FUlIobWNhc3QtPm1jKTsKIAkJY2xlYXJfYml0KElQT0lCX01DQVNUX0ZMQUdfQlVTWSwgJm1jYXN0LT5mbGFncyk7Ci0JCWNvbXBsZXRlKCZtY2FzdC0+ZG9uZSk7Ci0JCWlwb2liX3dhcm4ocHJpdiwgImliX3NhX2pvaW5fbXVsdGljYXN0IGZvciBzZW5kb25seSBqb2luICIKLQkJCSAgICJmYWlsZWQgKHJldCA9ICVkKVxuIiwgcmV0KTsKKwkJaXBvaWJfd2Fybihwcml2LCAiaWJfc2Ffam9pbl9tdWx0aWNhc3QgZmFpbGVkIChyZXQgPSAlZClcbiIsCisJCQkgICByZXQpOwogCX0gZWxzZSB7Ci0JCWlwb2liX2RiZ19tY2FzdChwcml2LCAibm8gbXVsdGljYXN0IHJlY29yZCBmb3IgJXBJNiwgc3RhcnRpbmcgIgotCQkJCSJzZW5kb25seSBqb2luXG4iLCBtY2FzdC0+bWNtZW1iZXIubWdpZC5yYXcpOworCQlpcG9pYl9kYmdfbWNhc3QocHJpdiwgIm5vIG11bHRpY2FzdCByZWNvcmQgZm9yICVwSTYsIHN0YXJ0aW5nIGpvaW5cbiIsCisJCQkJbWNhc3QtPm1jbWVtYmVyLm1naWQucmF3KTsKIAl9Ci0JbXV0ZXhfdW5sb2NrKCZtY2FzdF9tdXRleCk7CiAKIAlyZXR1cm4gcmV0OwogfQpAQCAtMzc1LDI5ICszNTksMTggQEAKIAkJCQkJCSAgIGNhcnJpZXJfb25fdGFzayk7CiAJc3RydWN0IGliX3BvcnRfYXR0ciBhdHRyOwogCisJLyoKKwkgKiBUYWtlIHJ0bmxfbG9jayB0byBhdm9pZCByYWNpbmcgd2l0aCBpcG9pYl9zdG9wKCkgYW5kCisJICogdHVybmluZyB0aGUgY2FycmllciBiYWNrIG9uIHdoaWxlIGEgZGV2aWNlIGlzIGJlaW5nCisJICogcmVtb3ZlZC4KKwkgKi8KIAlpZiAoaWJfcXVlcnlfcG9ydChwcml2LT5jYSwgcHJpdi0+cG9ydCwgJmF0dHIpIHx8CiAJICAgIGF0dHIuc3RhdGUgIT0gSUJfUE9SVF9BQ1RJVkUpIHsKIAkJaXBvaWJfZGJnKHByaXYsICJLZWVwaW5nIGNhcnJpZXIgb2ZmIHVudGlsIElCIHBvcnQgaXMgYWN0aXZlXG4iKTsKIAkJcmV0dXJuOwogCX0KIAotCS8qCi0JICogVGFrZSBydG5sX2xvY2sgdG8gYXZvaWQgcmFjaW5nIHdpdGggaXBvaWJfc3RvcCgpIGFuZAotCSAqIHR1cm5pbmcgdGhlIGNhcnJpZXIgYmFjayBvbiB3aGlsZSBhIGRldmljZSBpcyBiZWluZwotCSAqIHJlbW92ZWQuICBIb3dldmVyLCBpcG9pYl9zdG9wKCkgd2lsbCBhdHRlbXB0IHRvIGZsdXNoCi0JICogdGhlIHdvcmtxdWV1ZSB3aGlsZSBob2xkaW5nIHRoZSBydG5sIGxvY2ssIHNvIGxvb3AKLQkgKiBvbiB0cnlsb2NrIHVudGlsIGVpdGhlciB3ZSBnZXQgdGhlIGxvY2sgb3Igd2Ugc2VlCi0JICogRkxBR19BRE1JTl9VUCBnbyBhd2F5IGFzIHRoYXQgc2lnbmFscyB0aGF0IHdlIGFyZSBiYWlsaW5nCi0JICogYW5kIGNhbiBzYWZlbHkgaWdub3JlIHRoZSBjYXJyaWVyIG9uIHdvcmsuCi0JICovCi0Jd2hpbGUgKCFydG5sX3RyeWxvY2soKSkgewotCQlpZiAoIXRlc3RfYml0KElQT0lCX0ZMQUdfQURNSU5fVVAsICZwcml2LT5mbGFncykpCi0JCQlyZXR1cm47Ci0JCWVsc2UKLQkJCW1zbGVlcCgyMCk7Ci0JfQotCWlmICghaXBvaWJfY21fYWRtaW5fZW5hYmxlZChwcml2LT5kZXYpKQotCQlkZXZfc2V0X210dShwcml2LT5kZXYsIG1pbihwcml2LT5tY2FzdF9tdHUsIHByaXYtPmFkbWluX210dSkpOworCXJ0bmxfbG9jaygpOwogCW5ldGlmX2NhcnJpZXJfb24ocHJpdi0+ZGV2KTsKIAlydG5sX3VubG9jaygpOwogfQpAQCAtNDEyLDYzICszODUsNjAgQEAKIAlpcG9pYl9kYmdfbWNhc3QocHJpdiwgImpvaW4gY29tcGxldGlvbiBmb3IgJXBJNiAoc3RhdHVzICVkKVxuIiwKIAkJCW1jYXN0LT5tY21lbWJlci5tZ2lkLnJhdywgc3RhdHVzKTsKIAotCS8qCi0JICogV2UgaGF2ZSB0byB0YWtlIHRoZSBtdXRleCB0byBmb3JjZSBtY2FzdF9qb2luIHRvCi0JICogcmV0dXJuIGZyb20gaWJfc2FfbXVsdGljYXN0X2pvaW4gYW5kIHNldCBtY2FzdC0+bWMgdG8gYQotCSAqIHZhbGlkIHZhbHVlLiAgT3RoZXJ3aXNlIHdlIHdlcmUgcmFjaW5nIHdpdGggb3Vyc2VsdmVzIGluCi0JICogdGhhdCB3ZSBtaWdodCBmYWlsIGhlcmUsIGJ1dCBnZXQgYSB2YWxpZCByZXR1cm4gZnJvbQotCSAqIGliX3NhX211bHRpY2FzdF9qb2luIGFmdGVyIHdlIGhhZCBjbGVhcmVkIG1jYXN0LT5tYyBoZXJlLAotCSAqIHJlc3VsdGluZyBpbiBtaXMtbWF0Y2hlZCBqb2lucyBhbmQgbGVhdmVzIGFuZCBhIGRlYWRsb2NrCi0JICovCi0JbXV0ZXhfbG9jaygmbWNhc3RfbXV0ZXgpOwotCiAJLyogV2UgdHJhcCBmb3IgcG9ydCBldmVudHMgb3Vyc2VsdmVzLiAqLwotCWlmIChzdGF0dXMgPT0gLUVORVRSRVNFVCkKKwlpZiAoc3RhdHVzID09IC1FTkVUUkVTRVQpIHsKKwkJc3RhdHVzID0gMDsKIAkJZ290byBvdXQ7CisJfQogCiAJaWYgKCFzdGF0dXMpCiAJCXN0YXR1cyA9IGlwb2liX21jYXN0X2pvaW5fZmluaXNoKG1jYXN0LCAmbXVsdGljYXN0LT5yZWMpOwogCiAJaWYgKCFzdGF0dXMpIHsKIAkJbWNhc3QtPmJhY2tvZmYgPSAxOworCQltdXRleF9sb2NrKCZtY2FzdF9tdXRleCk7CiAJCWlmICh0ZXN0X2JpdChJUE9JQl9NQ0FTVF9SVU4sICZwcml2LT5mbGFncykpCi0JCQlxdWV1ZV9kZWxheWVkX3dvcmsocHJpdi0+d3EsICZwcml2LT5tY2FzdF90YXNrLCAwKTsKKwkJCXF1ZXVlX2RlbGF5ZWRfd29yayhpcG9pYl93b3JrcXVldWUsCisJCQkJCSAgICZwcml2LT5tY2FzdF90YXNrLCAwKTsKKwkJbXV0ZXhfdW5sb2NrKCZtY2FzdF9tdXRleCk7CiAKIAkJLyoKLQkJICogRGVmZXIgY2FycmllciBvbiB3b3JrIHRvIHByaXYtPndxIHRvIGF2b2lkIGEKKwkJICogRGVmZXIgY2FycmllciBvbiB3b3JrIHRvIGlwb2liX3dvcmtxdWV1ZSB0byBhdm9pZCBhCiAJCSAqIGRlYWRsb2NrIG9uIHJ0bmxfbG9jayBoZXJlLgogCQkgKi8KIAkJaWYgKG1jYXN0ID09IHByaXYtPmJyb2FkY2FzdCkKLQkJCXF1ZXVlX3dvcmsocHJpdi0+d3EsICZwcml2LT5jYXJyaWVyX29uX3Rhc2spOwotCX0gZWxzZSB7Ci0JCWlmIChtY2FzdC0+bG9nY291bnQrKyA8IDIwKSB7Ci0JCQlpZiAoc3RhdHVzID09IC1FVElNRURPVVQgfHwgc3RhdHVzID09IC1FQUdBSU4pIHsKLQkJCQlpcG9pYl9kYmdfbWNhc3QocHJpdiwgIm11bHRpY2FzdCBqb2luIGZhaWxlZCBmb3IgJXBJNiwgc3RhdHVzICVkXG4iLAotCQkJCQkJbWNhc3QtPm1jbWVtYmVyLm1naWQucmF3LCBzdGF0dXMpOwotCQkJfSBlbHNlIHsKLQkJCQlpcG9pYl93YXJuKHByaXYsICJtdWx0aWNhc3Qgam9pbiBmYWlsZWQgZm9yICVwSTYsIHN0YXR1cyAlZFxuIiwKLQkJCQkJICAgbWNhc3QtPm1jbWVtYmVyLm1naWQucmF3LCBzdGF0dXMpOwotCQkJfQotCQl9CisJCQlxdWV1ZV93b3JrKGlwb2liX3dvcmtxdWV1ZSwgJnByaXYtPmNhcnJpZXJfb25fdGFzayk7CiAKLQkJbWNhc3QtPmJhY2tvZmYgKj0gMjsKLQkJaWYgKG1jYXN0LT5iYWNrb2ZmID4gSVBPSUJfTUFYX0JBQ0tPRkZfU0VDT05EUykKLQkJCW1jYXN0LT5iYWNrb2ZmID0gSVBPSUJfTUFYX0JBQ0tPRkZfU0VDT05EUzsKLQl9Ci1vdXQ6Ci0Jc3Bpbl9sb2NrX2lycSgmcHJpdi0+bG9jayk7Ci0JY2xlYXJfYml0KElQT0lCX01DQVNUX0ZMQUdfQlVTWSwgJm1jYXN0LT5mbGFncyk7Ci0JaWYgKHN0YXR1cykKLQkJbWNhc3QtPm1jID0gTlVMTDsKLQljb21wbGV0ZSgmbWNhc3QtPmRvbmUpOwotCWlmIChzdGF0dXMgPT0gLUVORVRSRVNFVCkKIAkJc3RhdHVzID0gMDsKLQlpZiAoc3RhdHVzICYmIHRlc3RfYml0KElQT0lCX01DQVNUX1JVTiwgJnByaXYtPmZsYWdzKSkKLQkJcXVldWVfZGVsYXllZF93b3JrKHByaXYtPndxLCAmcHJpdi0+bWNhc3RfdGFzaywKKwkJZ290byBvdXQ7CisJfQorCisJaWYgKG1jYXN0LT5sb2djb3VudCsrIDwgMjApIHsKKwkJaWYgKHN0YXR1cyA9PSAtRVRJTUVET1VUIHx8IHN0YXR1cyA9PSAtRUFHQUlOKSB7CisJCQlpcG9pYl9kYmdfbWNhc3QocHJpdiwgIm11bHRpY2FzdCBqb2luIGZhaWxlZCBmb3IgJXBJNiwgc3RhdHVzICVkXG4iLAorCQkJCQltY2FzdC0+bWNtZW1iZXIubWdpZC5yYXcsIHN0YXR1cyk7CisJCX0gZWxzZSB7CisJCQlpcG9pYl93YXJuKHByaXYsICJtdWx0aWNhc3Qgam9pbiBmYWlsZWQgZm9yICVwSTYsIHN0YXR1cyAlZFxuIiwKKwkJCQkgICBtY2FzdC0+bWNtZW1iZXIubWdpZC5yYXcsIHN0YXR1cyk7CisJCX0KKwl9CisKKwltY2FzdC0+YmFja29mZiAqPSAyOworCWlmIChtY2FzdC0+YmFja29mZiA+IElQT0lCX01BWF9CQUNLT0ZGX1NFQ09ORFMpCisJCW1jYXN0LT5iYWNrb2ZmID0gSVBPSUJfTUFYX0JBQ0tPRkZfU0VDT05EUzsKKworCS8qIENsZWFyIHRoZSBidXN5IGZsYWcgc28gd2UgdHJ5IGFnYWluICovCisJc3RhdHVzID0gdGVzdF9hbmRfY2xlYXJfYml0KElQT0lCX01DQVNUX0ZMQUdfQlVTWSwgJm1jYXN0LT5mbGFncyk7CisKKwltdXRleF9sb2NrKCZtY2FzdF9tdXRleCk7CisJc3Bpbl9sb2NrX2lycSgmcHJpdi0+bG9jayk7CisJaWYgKHRlc3RfYml0KElQT0lCX01DQVNUX1JVTiwgJnByaXYtPmZsYWdzKSkKKwkJcXVldWVfZGVsYXllZF93b3JrKGlwb2liX3dvcmtxdWV1ZSwgJnByaXYtPm1jYXN0X3Rhc2ssCiAJCQkJICAgbWNhc3QtPmJhY2tvZmYgKiBIWik7CiAJc3Bpbl91bmxvY2tfaXJxKCZwcml2LT5sb2NrKTsKIAltdXRleF91bmxvY2soJm1jYXN0X211dGV4KTsKLQorb3V0OgorCWNvbXBsZXRlKCZtY2FzdC0+ZG9uZSk7CiAJcmV0dXJuIHN0YXR1czsKIH0KIApAQCAtNTE3LDkgKzQ4NywxMCBAQAogCQlyZWMuaG9wX2xpbWl0CSAgPSBwcml2LT5icm9hZGNhc3QtPm1jbWVtYmVyLmhvcF9saW1pdDsKIAl9CiAKLQltdXRleF9sb2NrKCZtY2FzdF9tdXRleCk7Ci0JaW5pdF9jb21wbGV0aW9uKCZtY2FzdC0+ZG9uZSk7CiAJc2V0X2JpdChJUE9JQl9NQ0FTVF9GTEFHX0JVU1ksICZtY2FzdC0+ZmxhZ3MpOworCWluaXRfY29tcGxldGlvbigmbWNhc3QtPmRvbmUpOworCXNldF9iaXQoSVBPSUJfTUNBU1RfSk9JTl9TVEFSVEVELCAmbWNhc3QtPmZsYWdzKTsKKwogCW1jYXN0LT5tYyA9IGliX3NhX2pvaW5fbXVsdGljYXN0KCZpcG9pYl9zYV9jbGllbnQsIHByaXYtPmNhLCBwcml2LT5wb3J0LAogCQkJCQkgJnJlYywgY29tcF9tYXNrLCBHRlBfS0VSTkVMLAogCQkJCQkgaXBvaWJfbWNhc3Rfam9pbl9jb21wbGV0ZSwgbWNhc3QpOwpAQCAtNTMzLDExICs1MDQsMTMgQEAKIAkJaWYgKG1jYXN0LT5iYWNrb2ZmID4gSVBPSUJfTUFYX0JBQ0tPRkZfU0VDT05EUykKIAkJCW1jYXN0LT5iYWNrb2ZmID0gSVBPSUJfTUFYX0JBQ0tPRkZfU0VDT05EUzsKIAorCQltdXRleF9sb2NrKCZtY2FzdF9tdXRleCk7CiAJCWlmICh0ZXN0X2JpdChJUE9JQl9NQ0FTVF9SVU4sICZwcml2LT5mbGFncykpCi0JCQlxdWV1ZV9kZWxheWVkX3dvcmsocHJpdi0+d3EsICZwcml2LT5tY2FzdF90YXNrLAorCQkJcXVldWVfZGVsYXllZF93b3JrKGlwb2liX3dvcmtxdWV1ZSwKKwkJCQkJICAgJnByaXYtPm1jYXN0X3Rhc2ssCiAJCQkJCSAgIG1jYXN0LT5iYWNrb2ZmICogSFopOworCQltdXRleF91bmxvY2soJm1jYXN0X211dGV4KTsKIAl9Ci0JbXV0ZXhfdW5sb2NrKCZtY2FzdF9tdXRleCk7CiB9CiAKIHZvaWQgaXBvaWJfbWNhc3Rfam9pbl90YXNrKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yaykKQEAgLTU3NCw4ICs1NDcsOCBAQAogCQkJaXBvaWJfd2Fybihwcml2LCAiZmFpbGVkIHRvIGFsbG9jYXRlIGJyb2FkY2FzdCBncm91cFxuIik7CiAJCQltdXRleF9sb2NrKCZtY2FzdF9tdXRleCk7CiAJCQlpZiAodGVzdF9iaXQoSVBPSUJfTUNBU1RfUlVOLCAmcHJpdi0+ZmxhZ3MpKQotCQkJCXF1ZXVlX2RlbGF5ZWRfd29yayhwcml2LT53cSwgJnByaXYtPm1jYXN0X3Rhc2ssCi0JCQkJCQkgICBIWik7CisJCQkJcXVldWVfZGVsYXllZF93b3JrKGlwb2liX3dvcmtxdWV1ZSwKKwkJCQkJCSAgICZwcml2LT5tY2FzdF90YXNrLCBIWik7CiAJCQltdXRleF91bmxvY2soJm1jYXN0X211dGV4KTsKIAkJCXJldHVybjsKIAkJfQpAQCAtNTkwLDggKzU2Myw3IEBACiAJfQogCiAJaWYgKCF0ZXN0X2JpdChJUE9JQl9NQ0FTVF9GTEFHX0FUVEFDSEVELCAmcHJpdi0+YnJvYWRjYXN0LT5mbGFncykpIHsKLQkJaWYgKElTX0VSUl9PUl9OVUxMKHByaXYtPmJyb2FkY2FzdC0+bWMpICYmCi0JCSAgICAhdGVzdF9iaXQoSVBPSUJfTUNBU1RfRkxBR19CVVNZLCAmcHJpdi0+YnJvYWRjYXN0LT5mbGFncykpCisJCWlmICghdGVzdF9iaXQoSVBPSUJfTUNBU1RfRkxBR19CVVNZLCAmcHJpdi0+YnJvYWRjYXN0LT5mbGFncykpCiAJCQlpcG9pYl9tY2FzdF9qb2luKGRldiwgcHJpdi0+YnJvYWRjYXN0LCAwKTsKIAkJcmV0dXJuOwogCX0KQEAgLTU5OSwzMyArNTcxLDIzIEBACiAJd2hpbGUgKDEpIHsKIAkJc3RydWN0IGlwb2liX21jYXN0ICptY2FzdCA9IE5VTEw7CiAKLQkJLyoKLQkJICogTmVlZCB0aGUgbXV0ZXggc28gb3VyIGZsYWdzIGFyZSBjb25zaXN0ZW50LCBuZWVkIHRoZQotCQkgKiBwcml2LT5sb2NrIHNvIHdlIGRvbid0IHJhY2Ugd2l0aCBsaXN0IHJlbW92YWxzIGluIGVpdGhlcgotCQkgKiBtY2FzdF9kZXZfZmx1c2ggb3IgbWNhc3RfcmVzdGFydF90YXNrCi0JCSAqLwotCQltdXRleF9sb2NrKCZtY2FzdF9tdXRleCk7CiAJCXNwaW5fbG9ja19pcnEoJnByaXYtPmxvY2spOwogCQlsaXN0X2Zvcl9lYWNoX2VudHJ5KG1jYXN0LCAmcHJpdi0+bXVsdGljYXN0X2xpc3QsIGxpc3QpIHsKLQkJCWlmIChJU19FUlJfT1JfTlVMTChtY2FzdC0+bWMpICYmCi0JCQkgICAgIXRlc3RfYml0KElQT0lCX01DQVNUX0ZMQUdfQlVTWSwgJm1jYXN0LT5mbGFncykgJiYKLQkJCSAgICAhdGVzdF9iaXQoSVBPSUJfTUNBU1RfRkxBR19BVFRBQ0hFRCwgJm1jYXN0LT5mbGFncykpIHsKKwkJCWlmICghdGVzdF9iaXQoSVBPSUJfTUNBU1RfRkxBR19TRU5ET05MWSwgJm1jYXN0LT5mbGFncykKKwkJCSAgICAmJiAhdGVzdF9iaXQoSVBPSUJfTUNBU1RfRkxBR19CVVNZLCAmbWNhc3QtPmZsYWdzKQorCQkJICAgICYmICF0ZXN0X2JpdChJUE9JQl9NQ0FTVF9GTEFHX0FUVEFDSEVELCAmbWNhc3QtPmZsYWdzKSkgewogCQkJCS8qIEZvdW5kIHRoZSBuZXh0IHVuam9pbmVkIGdyb3VwICovCiAJCQkJYnJlYWs7CiAJCQl9CiAJCX0KIAkJc3Bpbl91bmxvY2tfaXJxKCZwcml2LT5sb2NrKTsKLQkJbXV0ZXhfdW5sb2NrKCZtY2FzdF9tdXRleCk7CiAKIAkJaWYgKCZtY2FzdC0+bGlzdCA9PSAmcHJpdi0+bXVsdGljYXN0X2xpc3QpIHsKIAkJCS8qIEFsbCBkb25lICovCiAJCQlicmVhazsKIAkJfQogCi0JCWlmICh0ZXN0X2JpdChJUE9JQl9NQ0FTVF9GTEFHX1NFTkRPTkxZLCAmbWNhc3QtPmZsYWdzKSkKLQkJCWlwb2liX21jYXN0X3NlbmRvbmx5X2pvaW4obWNhc3QpOwotCQllbHNlCi0JCQlpcG9pYl9tY2FzdF9qb2luKGRldiwgbWNhc3QsIDEpOworCQlpcG9pYl9tY2FzdF9qb2luKGRldiwgbWNhc3QsIDEpOwogCQlyZXR1cm47CiAJfQogCkBAIC02NDIsMTMgKzYwNCwxMyBAQAogCiAJbXV0ZXhfbG9jaygmbWNhc3RfbXV0ZXgpOwogCWlmICghdGVzdF9hbmRfc2V0X2JpdChJUE9JQl9NQ0FTVF9SVU4sICZwcml2LT5mbGFncykpCi0JCXF1ZXVlX2RlbGF5ZWRfd29yayhwcml2LT53cSwgJnByaXYtPm1jYXN0X3Rhc2ssIDApOworCQlxdWV1ZV9kZWxheWVkX3dvcmsoaXBvaWJfd29ya3F1ZXVlLCAmcHJpdi0+bWNhc3RfdGFzaywgMCk7CiAJbXV0ZXhfdW5sb2NrKCZtY2FzdF9tdXRleCk7CiAKIAlyZXR1cm4gMDsKIH0KIAotaW50IGlwb2liX21jYXN0X3N0b3BfdGhyZWFkKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCitpbnQgaXBvaWJfbWNhc3Rfc3RvcF90aHJlYWQoc3RydWN0IG5ldF9kZXZpY2UgKmRldiwgaW50IGZsdXNoKQogewogCXN0cnVjdCBpcG9pYl9kZXZfcHJpdiAqcHJpdiA9IG5ldGRldl9wcml2KGRldik7CiAKQEAgLTY1OSw3ICs2MjEsOCBAQAogCWNhbmNlbF9kZWxheWVkX3dvcmsoJnByaXYtPm1jYXN0X3Rhc2spOwogCW11dGV4X3VubG9jaygmbWNhc3RfbXV0ZXgpOwogCi0JZmx1c2hfd29ya3F1ZXVlKHByaXYtPndxKTsKKwlpZiAoZmx1c2gpCisJCWZsdXNoX3dvcmtxdWV1ZShpcG9pYl93b3JrcXVldWUpOwogCiAJcmV0dXJuIDA7CiB9CkBAIC02NzAsOSArNjMzLDYgQEAKIAlpbnQgcmV0ID0gMDsKIAogCWlmICh0ZXN0X2FuZF9jbGVhcl9iaXQoSVBPSUJfTUNBU1RfRkxBR19CVVNZLCAmbWNhc3QtPmZsYWdzKSkKLQkJaXBvaWJfd2Fybihwcml2LCAiaXBvaWJfbWNhc3RfbGVhdmUgb24gYW4gaW4tZmxpZ2h0IGpvaW5cbiIpOwotCi0JaWYgKCFJU19FUlJfT1JfTlVMTChtY2FzdC0+bWMpKQogCQlpYl9zYV9mcmVlX211bHRpY2FzdChtY2FzdC0+bWMpOwogCiAJaWYgKHRlc3RfYW5kX2NsZWFyX2JpdChJUE9JQl9NQ0FTVF9GTEFHX0FUVEFDSEVELCAmbWNhc3QtPmZsYWdzKSkgewpAQCAtNzI1LDggKzY4NSw2IEBACiAJCW1lbWNweShtY2FzdC0+bWNtZW1iZXIubWdpZC5yYXcsIG1naWQsIHNpemVvZiAodW5pb24gaWJfZ2lkKSk7CiAJCV9faXBvaWJfbWNhc3RfYWRkKGRldiwgbWNhc3QpOwogCQlsaXN0X2FkZF90YWlsKCZtY2FzdC0+bGlzdCwgJnByaXYtPm11bHRpY2FzdF9saXN0KTsKLQkJaWYgKCF0ZXN0X2FuZF9zZXRfYml0KElQT0lCX01DQVNUX1JVTiwgJnByaXYtPmZsYWdzKSkKLQkJCXF1ZXVlX2RlbGF5ZWRfd29yayhwcml2LT53cSwgJnByaXYtPm1jYXN0X3Rhc2ssIDApOwogCX0KIAogCWlmICghbWNhc3QtPmFoKSB7CkBAIC03NDAsNiArNjk4LDggQEAKIAkJaWYgKHRlc3RfYml0KElQT0lCX01DQVNUX0ZMQUdfQlVTWSwgJm1jYXN0LT5mbGFncykpCiAJCQlpcG9pYl9kYmdfbWNhc3QocHJpdiwgIm5vIGFkZHJlc3MgdmVjdG9yLCAiCiAJCQkJCSJidXQgbXVsdGljYXN0IGpvaW4gYWxyZWFkeSBzdGFydGVkXG4iKTsKKwkJZWxzZSBpZiAodGVzdF9iaXQoSVBPSUJfTUNBU1RfRkxBR19TRU5ET05MWSwgJm1jYXN0LT5mbGFncykpCisJCQlpcG9pYl9tY2FzdF9zZW5kb25seV9qb2luKG1jYXN0KTsKIAogCQkvKgogCQkgKiBJZiBsb29rdXAgY29tcGxldGVzIGJldHdlZW4gaGVyZSBhbmQgb3V0OiwgZG9uJ3QKQEAgLTc5OSwxMiArNzU5LDkgQEAKIAogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnByaXYtPmxvY2ssIGZsYWdzKTsKIAotCS8qCi0JICogbWFrZSBzdXJlIHRoZSBpbi1mbGlnaHQgam9pbnMgaGF2ZSBmaW5pc2hlZCBiZWZvcmUgd2UgYXR0ZW1wdAotCSAqIHRvIGxlYXZlCi0JICovCisJLyogc2VwZXJhdGUgYmV0d2VlbiB0aGUgd2FpdCB0byB0aGUgbGVhdmUqLwogCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShtY2FzdCwgdG1jYXN0LCAmcmVtb3ZlX2xpc3QsIGxpc3QpCi0JCWlmICh0ZXN0X2JpdChJUE9JQl9NQ0FTVF9GTEFHX0JVU1ksICZtY2FzdC0+ZmxhZ3MpKQorCQlpZiAodGVzdF9iaXQoSVBPSUJfTUNBU1RfSk9JTl9TVEFSVEVELCAmbWNhc3QtPmZsYWdzKSkKIAkJCXdhaXRfZm9yX2NvbXBsZXRpb24oJm1jYXN0LT5kb25lKTsKIAogCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShtY2FzdCwgdG1jYXN0LCAmcmVtb3ZlX2xpc3QsIGxpc3QpIHsKQEAgLTgzNyw2ICs3OTQsOCBAQAogCiAJaXBvaWJfZGJnX21jYXN0KHByaXYsICJyZXN0YXJ0aW5nIG11bHRpY2FzdCB0YXNrXG4iKTsKIAorCWlwb2liX21jYXN0X3N0b3BfdGhyZWFkKGRldiwgMCk7CisKIAlsb2NhbF9pcnFfc2F2ZShmbGFncyk7CiAJbmV0aWZfYWRkcl9sb2NrKGRldik7CiAJc3Bpbl9sb2NrKCZwcml2LT5sb2NrKTsKQEAgLTkyMSwzOCArODgwLDE0IEBACiAJbmV0aWZfYWRkcl91bmxvY2soZGV2KTsKIAlsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7CiAKLQkvKgotCSAqIG1ha2Ugc3VyZSB0aGUgaW4tZmxpZ2h0IGpvaW5zIGhhdmUgZmluaXNoZWQgYmVmb3JlIHdlIGF0dGVtcHQKLQkgKiB0byBsZWF2ZQotCSAqLwotCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShtY2FzdCwgdG1jYXN0LCAmcmVtb3ZlX2xpc3QsIGxpc3QpCi0JCWlmICh0ZXN0X2JpdChJUE9JQl9NQ0FTVF9GTEFHX0JVU1ksICZtY2FzdC0+ZmxhZ3MpKQotCQkJd2FpdF9mb3JfY29tcGxldGlvbigmbWNhc3QtPmRvbmUpOwotCi0JLyoKLQkgKiBXZSBoYXZlIHRvIGNhbmNlbCBvdXRzaWRlIG9mIHRoZSBzcGlubG9jaywgYnV0IHdlIGhhdmUgdG8KLQkgKiB0YWtlIHRoZSBydG5sIGxvY2sgb3IgZWxzZSB3ZSByYWNlIHdpdGggdGhlIHJlbW92YWwgb2YKLQkgKiBlbnRyaWVzIGZyb20gdGhlIHJlbW92ZSBsaXN0IGluIG1jYXN0X2Rldl9mbHVzaCBhcyBwYXJ0Ci0JICogb2YgaXBvaWJfc3RvcCgpLiAgV2UgZGV0ZWN0IHRoZSBkcm9wIG9mIHRoZSBBRE1JTl9VUCBmbGFnCi0JICogdG8gc2lnbmFsIHRoYXQgd2UgaGF2ZSBoaXQgdGhpcyBwYXJ0aWN1bGFyIHJhY2UsIGFuZCB3ZQotCSAqIHJldHVybiBzaW5jZSB3ZSBrbm93IHdlIGRvbid0IG5lZWQgdG8gZG8gYW55dGhpbmcgZWxzZQotCSAqIGFueXdheS4KLQkgKi8KLQl3aGlsZSAoIXJ0bmxfdHJ5bG9jaygpKSB7Ci0JCWlmICghdGVzdF9iaXQoSVBPSUJfRkxBR19BRE1JTl9VUCwgJnByaXYtPmZsYWdzKSkKLQkJCXJldHVybjsKLQkJZWxzZQotCQkJbXNsZWVwKDIwKTsKLQl9CisJLyogV2UgaGF2ZSB0byBjYW5jZWwgb3V0c2lkZSBvZiB0aGUgc3BpbmxvY2sgKi8KIAlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUobWNhc3QsIHRtY2FzdCwgJnJlbW92ZV9saXN0LCBsaXN0KSB7CiAJCWlwb2liX21jYXN0X2xlYXZlKG1jYXN0LT5kZXYsIG1jYXN0KTsKIAkJaXBvaWJfbWNhc3RfZnJlZShtY2FzdCk7CiAJfQotCS8qCi0JICogUmVzdGFydCBvdXIgam9pbiB0YXNrIGlmIG5lZWRlZAotCSAqLwotCWlwb2liX21jYXN0X3N0YXJ0X3RocmVhZChkZXYpOwotCXJ0bmxfdW5sb2NrKCk7CisKKwlpZiAodGVzdF9iaXQoSVBPSUJfRkxBR19BRE1JTl9VUCwgJnByaXYtPmZsYWdzKSkKKwkJaXBvaWJfbWNhc3Rfc3RhcnRfdGhyZWFkKGRldik7CiB9CiAKICNpZmRlZiBDT05GSUdfSU5GSU5JQkFORF9JUE9JQl9ERUJVRwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL3VscC9pcG9pYi9pcG9pYl92ZXJicy5jIGIvZHJpdmVycy9pbmZpbmliYW5kL3VscC9pcG9pYi9pcG9pYl92ZXJicy5jCmluZGV4IGI3MmE3NTMuLmM1NmQ1ZDQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC91bHAvaXBvaWIvaXBvaWJfdmVyYnMuYworKysgYi9kcml2ZXJzL2luZmluaWJhbmQvdWxwL2lwb2liL2lwb2liX3ZlcmJzLmMKQEAgLTE0NSwyMCArMTQ1LDEwIEBACiAJaW50IHJldCwgc2l6ZTsKIAlpbnQgaTsKIAotCS8qCi0JICogdGhlIHZhcmlvdXMgSVBvSUIgdGFza3MgYXNzdW1lIHRoZXkgd2lsbCBuZXZlciByYWNlIGFnYWluc3QKLQkgKiB0aGVtc2VsdmVzLCBzbyBhbHdheXMgdXNlIGEgc2luZ2xlIHRocmVhZCB3b3JrcXVldWUKLQkgKi8KLQlwcml2LT53cSA9IGNyZWF0ZV9zaW5nbGV0aHJlYWRfd29ya3F1ZXVlKCJpcG9pYl93cSIpOwotCWlmICghcHJpdi0+d3EpIHsKLQkJcHJpbnRrKEtFUk5fV0FSTklORyAiaXBvaWI6IGZhaWxlZCB0byBhbGxvY2F0ZSBkZXZpY2UgV1FcbiIpOwotCQlyZXR1cm4gLUVOT0RFVjsKLQl9Ci0KIAlwcml2LT5wZCA9IGliX2FsbG9jX3BkKHByaXYtPmNhKTsKIAlpZiAoSVNfRVJSKHByaXYtPnBkKSkgewogCQlwcmludGsoS0VSTl9XQVJOSU5HICIlczogZmFpbGVkIHRvIGFsbG9jYXRlIFBEXG4iLCBjYS0+bmFtZSk7Ci0JCWdvdG8gb3V0X2ZyZWVfd3E7CisJCXJldHVybiAtRU5PREVWOwogCX0KIAogCXByaXYtPm1yID0gaWJfZ2V0X2RtYV9tcihwcml2LT5wZCwgSUJfQUNDRVNTX0xPQ0FMX1dSSVRFKTsKQEAgLTI1MiwxMCArMjQyLDYgQEAKIAogb3V0X2ZyZWVfcGQ6CiAJaWJfZGVhbGxvY19wZChwcml2LT5wZCk7Ci0KLW91dF9mcmVlX3dxOgotCWRlc3Ryb3lfd29ya3F1ZXVlKHByaXYtPndxKTsKLQlwcml2LT53cSA9IE5VTEw7CiAJcmV0dXJuIC1FTk9ERVY7CiB9CiAKQEAgLTI4NCwxMiArMjcwLDYgQEAKIAogCWlmIChpYl9kZWFsbG9jX3BkKHByaXYtPnBkKSkKIAkJaXBvaWJfd2Fybihwcml2LCAiaWJfZGVhbGxvY19wZCBmYWlsZWRcbiIpOwotCi0JaWYgKHByaXYtPndxKSB7Ci0JCWZsdXNoX3dvcmtxdWV1ZShwcml2LT53cSk7Ci0JCWRlc3Ryb3lfd29ya3F1ZXVlKHByaXYtPndxKTsKLQkJcHJpdi0+d3EgPSBOVUxMOwotCX0KIH0KIAogdm9pZCBpcG9pYl9ldmVudChzdHJ1Y3QgaWJfZXZlbnRfaGFuZGxlciAqaGFuZGxlciwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQvbW91c2UvZWxhbnRlY2guYyBiL2RyaXZlcnMvaW5wdXQvbW91c2UvZWxhbnRlY2guYwppbmRleCBmMmI5NzgwLi42ZTIyNjgyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lucHV0L21vdXNlL2VsYW50ZWNoLmMKKysrIGIvZHJpdmVycy9pbnB1dC9tb3VzZS9lbGFudGVjaC5jCkBAIC0xMDk3LDYgKzEwOTcsOCBAQAogICogQXN1cyBVWDMxICAgICAgICAgICAgICAgMHgzNjFmMDAgICAgICAgIDIwLCAxNSwgMGUgICAgICBjbGlja3BhZAogICogQXN1cyBVWDMyVkQgICAgICAgICAgICAgMHgzNjFmMDIgICAgICAgIDAwLCAxNSwgMGUgICAgICBjbGlja3BhZAogICogQXZhdGFyIEFWSVUtMTQ1QTIgICAgICAgMHgzNjFmMDAgICAgICAgID8gICAgICAgICAgICAgICBjbGlja3BhZAorICogRnVqaXRzdSBMSUZFQk9PSyBFNTQ0ICAgMHg0NzBmMDAgICAgICAgIGQwLCAxMiwgMDkgICAgICAyIGh3IGJ1dHRvbnMKKyAqIEZ1aml0c3UgTElGRUJPT0sgRTU1NCAgIDB4NTcwZjAxICAgICAgICA0MCwgMTQsIDBjICAgICAgMiBodyBidXR0b25zCiAgKiBGdWppdHN1IEg3MzAgICAgICAgICAgICAweDU3MGYwMCAgICAgICAgYzAsIDE0LCAwYyAgICAgIDMgaHcgYnV0dG9ucyAoKiopCiAgKiBHaWdhYnl0ZSBVMjQ0MiAgICAgICAgICAweDQ1MGYwMSAgICAgICAgNTgsIDE3LCAwYyAgICAgIDIgaHcgYnV0dG9ucwogICogTGVub3ZvIEw0MzAgICAgICAgICAgICAgMHgzNTBmMDIgICAgICAgIGI5LCAxNSwgMGMgICAgICAyIGh3IGJ1dHRvbnMgKCopCkBAIC0xNDc1LDYgKzE0NzcsMjAgQEAKIAkJCURNSV9NQVRDSChETUlfUFJPRFVDVF9OQU1FLCAiQ0VMU0lVUyBINzMwIiksCiAJCX0sCiAJfSwKKwl7CisJCS8qIEZ1aml0c3UgTElGRUJPT0sgRTU1NCAgZG9lcyBub3Qgd29yayB3aXRoIGNyY19lbmFibGVkID09IDAgKi8KKwkJLm1hdGNoZXMgPSB7CisJCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJGVUpJVFNVIiksCisJCQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIkxJRkVCT09LIEU1NTQiKSwKKwkJfSwKKwl9LAorCXsKKwkJLyogRnVqaXRzdSBMSUZFQk9PSyBFNTQ0ICBkb2VzIG5vdCB3b3JrIHdpdGggY3JjX2VuYWJsZWQgPT0gMCAqLworCQkubWF0Y2hlcyA9IHsKKwkJCURNSV9NQVRDSChETUlfU1lTX1ZFTkRPUiwgIkZVSklUU1UiKSwKKwkJCURNSV9NQVRDSChETUlfUFJPRFVDVF9OQU1FLCAiTElGRUJPT0sgRTU0NCIpLAorCQl9LAorCX0sCiAjZW5kaWYKIAl7IH0KIH07CkBAIC0xNTIwLDYgKzE1MzYsOCBAQAogCQljYXNlIDc6CiAJCWNhc2UgODoKIAkJY2FzZSA5OgorCQljYXNlIDEwOgorCQljYXNlIDEzOgogCQkJZXRkLT5od192ZXJzaW9uID0gNDsKIAkJCWJyZWFrOwogCQlkZWZhdWx0OgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbnB1dC9tb3VzZS9zeW5hcHRpY3MuYyBiL2RyaXZlcnMvaW5wdXQvbW91c2Uvc3luYXB0aWNzLmMKaW5kZXggZjk0NzI5Mi4uMjNlMjZlMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbnB1dC9tb3VzZS9zeW5hcHRpY3MuYworKysgYi9kcml2ZXJzL2lucHV0L21vdXNlL3N5bmFwdGljcy5jCkBAIC0xMzUsOCArMTM1LDkgQEAKIAkJMTIzMiwgNTcxMCwgMTE1NiwgNDY5NgogCX0sCiAJewotCQkoY29uc3QgY2hhciAqIGNvbnN0IFtdKXsiTEVOMDAzNCIsICJMRU4wMDM2IiwgIkxFTjAwMzkiLAotCQkJCQkiTEVOMjAwMiIsICJMRU4yMDA0IiwgTlVMTH0sCisJCShjb25zdCBjaGFyICogY29uc3QgW10peyJMRU4wMDM0IiwgIkxFTjAwMzYiLCAiTEVOMDAzNyIsCisJCQkJCSJMRU4wMDM5IiwgIkxFTjIwMDIiLCAiTEVOMjAwNCIsCisJCQkJCU5VTEx9LAogCQkxMDI0LCA1MTEyLCAyMDI0LCA0ODMyCiAJfSwKIAl7CkBAIC0xNjUsNyArMTY2LDcgQEAKIAkiTEVOMDAzNCIsIC8qIFQ0MzFzLCBMNDQwLCBMNTQwLCBUNTQwLCBXNTQwLCBYMSBDYXJib24gMm5kICovCiAJIkxFTjAwMzUiLCAvKiBYMjQwICovCiAJIkxFTjAwMzYiLCAvKiBUNDQwICovCi0JIkxFTjAwMzciLAorCSJMRU4wMDM3IiwgLyogWDEgQ2FyYm9uIDJuZCAqLwogCSJMRU4wMDM4IiwKIAkiTEVOMDAzOSIsIC8qIFQ0NDBzICovCiAJIkxFTjAwNDEiLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbnB1dC9zZXJpby9pODA0Mi14ODZpYTY0aW8uaCBiL2RyaXZlcnMvaW5wdXQvc2VyaW8vaTgwNDIteDg2aWE2NGlvLmgKaW5kZXggYzY2ZDFiNS4uYzExNTU2NSAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbnB1dC9zZXJpby9pODA0Mi14ODZpYTY0aW8uaAorKysgYi9kcml2ZXJzL2lucHV0L3NlcmlvL2k4MDQyLXg4NmlhNjRpby5oCkBAIC0xNTIsNiArMTUyLDE0IEBACiAJCX0sCiAJfSwKIAl7CisJCS8qIE1lZGlvbiBBa295YSBFNzIyNSAqLworCQkubWF0Y2hlcyA9IHsKKwkJCURNSV9NQVRDSChETUlfU1lTX1ZFTkRPUiwgIk1lZGlvbiIpLAorCQkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJBa295YSBFNzIyNSIpLAorCQkJRE1JX01BVENIKERNSV9QUk9EVUNUX1ZFUlNJT04sICIxLjAiKSwKKwkJfSwKKwl9LAorCXsKIAkJLyogQmx1ZSBGQjU2MDEgKi8KIAkJLm1hdGNoZXMgPSB7CiAJCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJibHVlIiksCkBAIC00MTUsNiArNDIzLDEzIEBACiAJCX0sCiAJfSwKIAl7CisJCS8qIEFjZXIgQXNwaXJlIDc3MzggKi8KKwkJLm1hdGNoZXMgPSB7CisJCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJBY2VyIiksCisJCQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIkFzcGlyZSA3NzM4IiksCisJCX0sCisJfSwKKwl7CiAJCS8qIEdlcmljb20gQmVsbGFnaW8gKi8KIAkJLm1hdGNoZXMgPSB7CiAJCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJHZXJpY29tIiksCkBAIC03NDUsNiArNzYwLDM1IEBACiAJeyB9CiB9OwogCisvKgorICogU29tZSBsYXB0b3BzIG5lZWQga2V5Ym9hcmQgcmVzZXQgYmVmb3JlIHByb2JpbmcgZm9yIHRoZSB0cmFja3BhZCB0byBnZXQKKyAqIGl0IGRldGVjdGVkLCBpbml0aWFsaXNlZCAmIGZpbmFsbHkgd29yay4KKyAqLworc3RhdGljIGNvbnN0IHN0cnVjdCBkbWlfc3lzdGVtX2lkIF9faW5pdGNvbnN0IGk4MDQyX2RtaV9rYmRyZXNldF90YWJsZVtdID0geworCXsKKwkJLyogR2lnYWJ5dGUgUDM1IHYyIC0gRWxhbnRlY2ggdG91Y2hwYWQgKi8KKwkJLm1hdGNoZXMgPSB7CisJCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJHSUdBQllURSIpLAorCQkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJQMzVWMiIpLAorCQl9LAorCX0sCisJCXsKKwkJLyogQW9ydXMgYnJhbmRlZCBHaWdhYnl0ZSBYMyBQbHVzIC0gRWxhbnRlY2ggdG91Y2hwYWQgKi8KKwkJLm1hdGNoZXMgPSB7CisJCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJHSUdBQllURSIpLAorCQkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJYMyIpLAorCQl9LAorCX0sCisJeworCQkvKiBHaWdhYnl0ZSBQMzQgLSBFbGFudGVjaCB0b3VjaHBhZCAqLworCQkubWF0Y2hlcyA9IHsKKwkJCURNSV9NQVRDSChETUlfU1lTX1ZFTkRPUiwgIkdJR0FCWVRFIiksCisJCQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIlAzNCIpLAorCQl9LAorCX0sCisJeyB9Cit9OworCiAjZW5kaWYgLyogQ09ORklHX1g4NiAqLwogCiAjaWZkZWYgQ09ORklHX1BOUApAQCAtMTA0MCw2ICsxMDg0LDkgQEAKIAlpZiAoZG1pX2NoZWNrX3N5c3RlbShpODA0Ml9kbWlfZHJpdGVrX3RhYmxlKSkKIAkJaTgwNDJfZHJpdGVrID0gdHJ1ZTsKIAorCWlmIChkbWlfY2hlY2tfc3lzdGVtKGk4MDQyX2RtaV9rYmRyZXNldF90YWJsZSkpCisJCWk4MDQyX2tiZHJlc2V0ID0gdHJ1ZTsKKwogCS8qCiAJICogQTIwIHdhcyBhbHJlYWR5IGVuYWJsZWQgZHVyaW5nIGVhcmx5IGtlcm5lbCBpbml0LiBCdXQgc29tZSBidWdneQogCSAqIEJJT1NlcyAoaW4gTVNJIExhcHRvcHMpIHJlcXVpcmUgQTIwIHRvIGJlIGVuYWJsZWQgdXNpbmcgODA0MiB0bwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbnB1dC9zZXJpby9pODA0Mi5jIGIvZHJpdmVycy9pbnB1dC9zZXJpby9pODA0Mi5jCmluZGV4IDkyNGU0YmYuLjk4NmE3MWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5wdXQvc2VyaW8vaTgwNDIuYworKysgYi9kcml2ZXJzL2lucHV0L3NlcmlvL2k4MDQyLmMKQEAgLTY3LDYgKzY3LDEwIEBACiBtb2R1bGVfcGFyYW1fbmFtZWQobm90aW1lb3V0LCBpODA0Ml9ub3RpbWVvdXQsIGJvb2wsIDApOwogTU9EVUxFX1BBUk1fREVTQyhub3RpbWVvdXQsICJJZ25vcmUgdGltZW91dHMgc2lnbmFsbGVkIGJ5IGk4MDQyIik7CiAKK3N0YXRpYyBib29sIGk4MDQyX2tiZHJlc2V0OworbW9kdWxlX3BhcmFtX25hbWVkKGtiZHJlc2V0LCBpODA0Ml9rYmRyZXNldCwgYm9vbCwgMCk7CitNT0RVTEVfUEFSTV9ERVNDKGtiZHJlc2V0LCAiUmVzZXQgZGV2aWNlIGNvbm5lY3RlZCB0byBLQkQgcG9ydCIpOworCiAjaWZkZWYgQ09ORklHX1g4Ngogc3RhdGljIGJvb2wgaTgwNDJfZHJpdGVrOwogbW9kdWxlX3BhcmFtX25hbWVkKGRyaXRlaywgaTgwNDJfZHJpdGVrLCBib29sLCAwKTsKQEAgLTc5MCw2ICs3OTQsMTYgQEAKIAkJcmV0dXJuIC0xOwogCiAvKgorICogUmVzZXQga2V5Ym9hcmQgKG5lZWRlZCBvbiBzb21lIGxhcHRvcHMgdG8gc3VjY2Vzc2Z1bGx5IGRldGVjdAorICogdG91Y2hwYWQsIGUuZy4sIHNvbWUgR2lnYWJ5dGUgbGFwdG9wIG1vZGVscyB3aXRoIEVsYW50ZWNoCisgKiB0b3VjaHBhZHMpLgorICovCisJaWYgKGk4MDQyX2tiZHJlc2V0KSB7CisJCXByX3dhcm4oIkF0dGVtcHRpbmcgdG8gcmVzZXQgZGV2aWNlIGNvbm5lY3RlZCB0byBLQkQgcG9ydFxuIik7CisJCWk4MDQyX2tiZF93cml0ZShOVUxMLCAodW5zaWduZWQgY2hhcikgMHhmZik7CisJfQorCisvKgogICogVGVzdCBBVVggSVJRIGRlbGl2ZXJ5IHRvIG1ha2Ugc3VyZSBCSU9TIGRpZCBub3QgZ3JhYiB0aGUgSVJRIGFuZAogICogdXNlZCBpdCBmb3IgYSBQQ0kgY2FyZCBvciBzb21ldGhpZyBlbHNlLgogICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lvbW11L3RlZ3JhLWdhcnQuYyBiL2RyaXZlcnMvaW9tbXUvdGVncmEtZ2FydC5jCmluZGV4IGY3MjJhMGMuLmM0OGRhMDUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW9tbXUvdGVncmEtZ2FydC5jCisrKyBiL2RyaXZlcnMvaW9tbXUvdGVncmEtZ2FydC5jCkBAIC0zMTUsNiArMzE1LDcgQEAKIAkuYXR0YWNoX2Rldgk9IGdhcnRfaW9tbXVfYXR0YWNoX2RldiwKIAkuZGV0YWNoX2Rldgk9IGdhcnRfaW9tbXVfZGV0YWNoX2RldiwKIAkubWFwCQk9IGdhcnRfaW9tbXVfbWFwLAorCS5tYXBfc2cJCT0gZGVmYXVsdF9pb21tdV9tYXBfc2csCiAJLnVubWFwCQk9IGdhcnRfaW9tbXVfdW5tYXAsCiAJLmlvdmFfdG9fcGh5cwk9IGdhcnRfaW9tbXVfaW92YV90b19waHlzLAogCS5wZ3NpemVfYml0bWFwCT0gR0FSVF9JT01NVV9QR1NJWkVTLApAQCAtMzk1LDcgKzM5Niw3IEBACiAJZG9fZ2FydF9zZXR1cChnYXJ0LCBOVUxMKTsKIAogCWdhcnRfaGFuZGxlID0gZ2FydDsKLQlidXNfc2V0X2lvbW11KCZwbGF0Zm9ybV9idXNfdHlwZSwgJmdhcnRfaW9tbXVfb3BzKTsKKwogCXJldHVybiAwOwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lycWNoaXAvaXJxLWF0bWVsLWFpYy1jb21tb24uYyBiL2RyaXZlcnMvaXJxY2hpcC9pcnEtYXRtZWwtYWljLWNvbW1vbi5jCmluZGV4IGQxMTFhYzcuLjYzY2QwMzEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaXJxY2hpcC9pcnEtYXRtZWwtYWljLWNvbW1vbi5jCisrKyBiL2RyaXZlcnMvaXJxY2hpcC9pcnEtYXRtZWwtYWljLWNvbW1vbi5jCkBAIC0yOCw3ICsyOCw3IEBACiAjZGVmaW5lIEFUOTFfQUlDX0lSUV9NSU5fUFJJT1JJVFkJMAogI2RlZmluZSBBVDkxX0FJQ19JUlFfTUFYX1BSSU9SSVRZCTcKIAotI2RlZmluZSBBVDkxX0FJQ19TUkNUWVBFCQlHRU5NQVNLKDcsIDYpCisjZGVmaW5lIEFUOTFfQUlDX1NSQ1RZUEUJCUdFTk1BU0soNiwgNSkKICNkZWZpbmUgQVQ5MV9BSUNfU1JDVFlQRV9MT1cJCSgwIDw8IDUpCiAjZGVmaW5lIEFUOTFfQUlDX1NSQ1RZUEVfRkFMTElORwkoMSA8PCA1KQogI2RlZmluZSBBVDkxX0FJQ19TUkNUWVBFX0hJR0gJCSgyIDw8IDUpCkBAIC03NCw3ICs3NCw3IEBACiAJCXJldHVybiAtRUlOVkFMOwogCX0KIAotCSp2YWwgJj0gQVQ5MV9BSUNfU1JDVFlQRTsKKwkqdmFsICY9IH5BVDkxX0FJQ19TUkNUWVBFOwogCSp2YWwgfD0gYWljX3R5cGU7CiAKIAlyZXR1cm4gMDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaXJxY2hpcC9pcnEtZ2ljLXYzLWl0cy5jIGIvZHJpdmVycy9pcnFjaGlwL2lycS1naWMtdjMtaXRzLmMKaW5kZXggODZlNDY4NC4uZDg5OTZiZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9pcnFjaGlwL2lycS1naWMtdjMtaXRzLmMKKysrIGIvZHJpdmVycy9pcnFjaGlwL2lycS1naWMtdjMtaXRzLmMKQEAgLTEwNTMsNyArMTA1Myw3IEBACiAJICogb2YgdHdvIGVudHJpZXMuIE5vLCB0aGUgYXJjaGl0ZWN0dXJlIGRvZXNuJ3QgbGV0IHlvdQogCSAqIGV4cHJlc3MgYW4gSVRUIHdpdGggYSBzaW5nbGUgZW50cnkuCiAJICovCi0JbnJfaXRlcyA9IG1heCgyLCByb3VuZHVwX3Bvd19vZl90d28obnZlY3MpKTsKKwlucl9pdGVzID0gbWF4KDJVTCwgcm91bmR1cF9wb3dfb2ZfdHdvKG52ZWNzKSk7CiAJc3ogPSBucl9pdGVzICogaXRzLT5pdGVfc2l6ZTsKIAlzeiA9IG1heChzeiwgSVRTX0lUVF9BTElHTikgKyBJVFNfSVRUX0FMSUdOIC0gMTsKIAlpdHQgPSBrbWFsbG9jKHN6LCBHRlBfS0VSTkVMKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaXJxY2hpcC9pcnEtaGlwMDQuYyBiL2RyaXZlcnMvaXJxY2hpcC9pcnEtaGlwMDQuYwppbmRleCAyOWI4ZjIxLi42YmMyZGViIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lycWNoaXAvaXJxLWhpcDA0LmMKKysrIGIvZHJpdmVycy9pcnFjaGlwL2lycS1oaXAwNC5jCkBAIC0zODEsNyArMzgxLDcgQEAKIAkgKiBJdCB3aWxsIGJlIHJlZmluZWQgYXMgZWFjaCBDUFUgcHJvYmVzIGl0cyBJRC4KIAkgKi8KIAlmb3IgKGkgPSAwOyBpIDwgTlJfSElQMDRfQ1BVX0lGOyBpKyspCi0JCWhpcDA0X2NwdV9tYXBbaV0gPSAweGZmOworCQloaXAwNF9jcHVfbWFwW2ldID0gMHhmZmZmOwogCiAJLyoKIAkgKiBGaW5kIG91dCBob3cgbWFueSBpbnRlcnJ1cHRzIGFyZSBzdXBwb3J0ZWQuCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lycWNoaXAvaXJxLW1pcHMtZ2ljLmMgYi9kcml2ZXJzL2lycWNoaXAvaXJxLW1pcHMtZ2ljLmMKaW5kZXggMmIwNDY4ZS4uNTZiOTZjNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9pcnFjaGlwL2lycS1taXBzLWdpYy5jCisrKyBiL2RyaXZlcnMvaXJxY2hpcC9pcnEtbWlwcy1naWMuYwpAQCAtMzcsNiArMzcsNyBAQAogc3RhdGljIGludCBnaWNfc2hhcmVkX2ludHJzOwogc3RhdGljIGludCBnaWNfdnBlczsKIHN0YXRpYyB1bnNpZ25lZCBpbnQgZ2ljX2NwdV9waW47CitzdGF0aWMgdW5zaWduZWQgaW50IHRpbWVyX2NwdV9waW47CiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIGdpY19sZXZlbF9pcnFfY29udHJvbGxlciwgZ2ljX2VkZ2VfaXJxX2NvbnRyb2xsZXI7CiAKIHN0YXRpYyB2b2lkIF9fZ2ljX2lycV9kaXNwYXRjaCh2b2lkKTsKQEAgLTYxNiw2ICs2MTcsOCBAQAogCQkJZ2ljX3dyaXRlKEdJQ19SRUcoVlBFX09USEVSLCBHSUNfVlBFX0NPTVBBUkVfTUFQKSwgdmFsKTsKIAkJCWJyZWFrOwogCQljYXNlIEdJQ19MT0NBTF9JTlRfVElNRVI6CisJCQkvKiBDT05GSUdfTUlQU19DTVAgd29ya2Fyb3VuZCAoc2VlIF9fZ2ljX2luaXQpICovCisJCQl2YWwgPSBHSUNfTUFQX1RPX1BJTl9NU0sgfCB0aW1lcl9jcHVfcGluOwogCQkJZ2ljX3dyaXRlKEdJQ19SRUcoVlBFX09USEVSLCBHSUNfVlBFX1RJTUVSX01BUCksIHZhbCk7CiAJCQlicmVhazsKIAkJY2FzZSBHSUNfTE9DQUxfSU5UX1BFUkZDVFI6CkBAIC03MTMsMTIgKzcxNiwzNiBAQAogCWlmIChjcHVfaGFzX3ZlaWMpIHsKIAkJLyogQWx3YXlzIHVzZSB2ZWN0b3IgMSBpbiBFSUMgbW9kZSAqLwogCQlnaWNfY3B1X3BpbiA9IDA7CisJCXRpbWVyX2NwdV9waW4gPSBnaWNfY3B1X3BpbjsKIAkJc2V0X3ZpX2hhbmRsZXIoZ2ljX2NwdV9waW4gKyBHSUNfUElOX1RPX1ZFQ19PRkZTRVQsCiAJCQkgICAgICAgX19naWNfaXJxX2Rpc3BhdGNoKTsKIAl9IGVsc2UgewogCQlnaWNfY3B1X3BpbiA9IGNwdV92ZWMgLSBHSUNfQ1BVX1BJTl9PRkZTRVQ7CiAJCWlycV9zZXRfY2hhaW5lZF9oYW5kbGVyKE1JUFNfQ1BVX0lSUV9CQVNFICsgY3B1X3ZlYywKIAkJCQkJZ2ljX2lycV9kaXNwYXRjaCk7CisJCS8qCisJCSAqIFdpdGggdGhlIENNUCBpbXBsZW1lbnRhdGlvbiBvZiBTTVAgKGRlcHJlY2F0ZWQpLCBvdGhlciBDUFVzCisJCSAqIGFyZSBzdGFydGVkIGJ5IHRoZSBib290bG9hZGVyIGFuZCBwdXQgaW50byBhIHRpbWVyIGJhc2VkCisJCSAqIHdhaXRpbmcgcG9sbCBsb29wLiBXZSBtdXN0IG5vdCByZS1yb3V0ZSB0aG9zZSBDUFUncyBsb2NhbAorCQkgKiB0aW1lciBpbnRlcnJ1cHRzIGFzIHRoZSB3YWl0IGluc3RydWN0aW9uIHdpbGwgbmV2ZXIgZmluaXNoLAorCQkgKiBzbyBqdXN0IGhhbmRsZSB3aGF0ZXZlciBDUFUgaW50ZXJydXB0IGl0IGlzIHJvdXRlZCB0byBieQorCQkgKiBkZWZhdWx0LgorCQkgKgorCQkgKiBUaGlzIHdvcmthcm91bmQgc2hvdWxkIGJlIHJlbW92ZWQgd2hlbiBDTVAgc3VwcG9ydCBpcworCQkgKiBkcm9wcGVkLgorCQkgKi8KKwkJaWYgKElTX0VOQUJMRUQoQ09ORklHX01JUFNfQ01QKSAmJgorCQkgICAgZ2ljX2xvY2FsX2lycV9pc19yb3V0YWJsZShHSUNfTE9DQUxfSU5UX1RJTUVSKSkgeworCQkJdGltZXJfY3B1X3BpbiA9IGdpY19yZWFkKEdJQ19SRUcoVlBFX0xPQ0FMLAorCQkJCQkJCSBHSUNfVlBFX1RJTUVSX01BUCkpICYKKwkJCQkJR0lDX01BUF9NU0s7CisJCQlpcnFfc2V0X2NoYWluZWRfaGFuZGxlcihNSVBTX0NQVV9JUlFfQkFTRSArCisJCQkJCQlHSUNfQ1BVX1BJTl9PRkZTRVQgKworCQkJCQkJdGltZXJfY3B1X3BpbiwKKwkJCQkJCWdpY19pcnFfZGlzcGF0Y2gpOworCQl9IGVsc2UgeworCQkJdGltZXJfY3B1X3BpbiA9IGdpY19jcHVfcGluOworCQl9CiAJfQogCiAJZ2ljX2lycV9kb21haW4gPSBpcnFfZG9tYWluX2FkZF9zaW1wbGUobm9kZSwgR0lDX05VTV9MT0NBTF9JTlRSUyArCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lycWNoaXAvaXJxLW10ay1zeXNpcnEuYyBiL2RyaXZlcnMvaXJxY2hpcC9pcnEtbXRrLXN5c2lycS5jCmluZGV4IDdlMzQyZGYuLjBiMGQyYzAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaXJxY2hpcC9pcnEtbXRrLXN5c2lycS5jCisrKyBiL2RyaXZlcnMvaXJxY2hpcC9pcnEtbXRrLXN5c2lycS5jCkBAIC0xMzcsOSArMTM3LDkgQEAKIAkJcmV0dXJuIC1FTk9NRU07CiAKIAljaGlwX2RhdGEtPmludHBvbF9iYXNlID0gb2ZfaW9fcmVxdWVzdF9hbmRfbWFwKG5vZGUsIDAsICJpbnRwb2wiKTsKLQlpZiAoIWNoaXBfZGF0YS0+aW50cG9sX2Jhc2UpIHsKKwlpZiAoSVNfRVJSKGNoaXBfZGF0YS0+aW50cG9sX2Jhc2UpKSB7CiAJCXByX2VycigibXRrX3N5c2lycTogdW5hYmxlIHRvIG1hcCBzeXNpcnEgcmVnaXN0ZXJcbiIpOwotCQlyZXQgPSAtRU5PTUVNOworCQlyZXQgPSBQVFJfRVJSKGNoaXBfZGF0YS0+aW50cG9sX2Jhc2UpOwogCQlnb3RvIG91dF9mcmVlOwogCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9pcnFjaGlwL2lycS1vbWFwLWludGMuYyBiL2RyaXZlcnMvaXJxY2hpcC9pcnEtb21hcC1pbnRjLmMKaW5kZXggMjg3MThkMy4uYzAzZjE0MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9pcnFjaGlwL2lycS1vbWFwLWludGMuYworKysgYi9kcml2ZXJzL2lycWNoaXAvaXJxLW9tYXAtaW50Yy5jCkBAIC0yNjMsNyArMjYzLDcgQEAKIAlyZXR1cm4gcmV0OwogfQogCi1zdGF0aWMgaW50IF9faW5pdCBvbWFwX2luaXRfaXJxX2xlZ2FjeSh1MzIgYmFzZSkKK3N0YXRpYyBpbnQgX19pbml0IG9tYXBfaW5pdF9pcnFfbGVnYWN5KHUzMiBiYXNlLCBzdHJ1Y3QgZGV2aWNlX25vZGUgKm5vZGUpCiB7CiAJaW50IGosIGlycV9iYXNlOwogCkBAIC0yNzcsNyArMjc3LDcgQEAKIAkJaXJxX2Jhc2UgPSAwOwogCX0KIAotCWRvbWFpbiA9IGlycV9kb21haW5fYWRkX2xlZ2FjeShOVUxMLCBvbWFwX25yX2lycXMsIGlycV9iYXNlLCAwLAorCWRvbWFpbiA9IGlycV9kb21haW5fYWRkX2xlZ2FjeShub2RlLCBvbWFwX25yX2lycXMsIGlycV9iYXNlLCAwLAogCQkJJmlycV9kb21haW5fc2ltcGxlX29wcywgTlVMTCk7CiAKIAlvbWFwX2lycV9zb2Z0X3Jlc2V0KCk7CkBAIC0zMDEsMTAgKzMwMSwyNiBAQAogewogCWludCByZXQ7CiAKLQlpZiAobm9kZSkKKwkvKgorCSAqIEZJWE1FIGxlZ2FjeSBPTUFQIERNQSBkcml2ZXIgc2l0dGluZyB1bmRlciBhcmNoL2FybS9wbGF0LW9tYXAvZG1hLmMKKwkgKiBkZXBlbmRzIGlzIHN0aWxsIG5vdCByZWFkeSBmb3IgbGluZWFyIElSUSBkb21haW5zOyBiZWNhdXNlIG9mIHRoYXQKKwkgKiB3ZSBuZWVkIHRvIHRlbXBvcmFyaWx5ICJibGFja2xpc3QiIE9NQVAyIGFuZCBPTUFQMyBkZXZpY2VzIGZyb20gdXNpbmcKKwkgKiBsaW5lYXIgSVJRIERvbWFpbiB1bnRpbCB0aGF0IGRyaXZlciBpcyBmaW5hbGx5IGZpeGVkLgorCSAqLworCWlmIChvZl9kZXZpY2VfaXNfY29tcGF0aWJsZShub2RlLCAidGksb21hcDItaW50YyIpIHx8CisJCQlvZl9kZXZpY2VfaXNfY29tcGF0aWJsZShub2RlLCAidGksb21hcDMtaW50YyIpKSB7CisJCXN0cnVjdCByZXNvdXJjZSByZXM7CisKKwkJaWYgKG9mX2FkZHJlc3NfdG9fcmVzb3VyY2Uobm9kZSwgMCwgJnJlcykpCisJCQlyZXR1cm4gLUVOT01FTTsKKworCQliYXNlID0gcmVzLnN0YXJ0OworCQlyZXQgPSBvbWFwX2luaXRfaXJxX2xlZ2FjeShiYXNlLCBub2RlKTsKKwl9IGVsc2UgaWYgKG5vZGUpIHsKIAkJcmV0ID0gb21hcF9pbml0X2lycV9vZihub2RlKTsKLQllbHNlCi0JCXJldCA9IG9tYXBfaW5pdF9pcnFfbGVnYWN5KGJhc2UpOworCX0gZWxzZSB7CisJCXJldCA9IG9tYXBfaW5pdF9pcnFfbGVnYWN5KGJhc2UsIE5VTEwpOworCX0KIAogCWlmIChyZXQgPT0gMCkKIAkJb21hcF9pcnFfZW5hYmxlX3Byb3RlY3Rpb24oKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaXNkbi9oYXJkd2FyZS9laWNvbi9tZXNzYWdlLmMgYi9kcml2ZXJzL2lzZG4vaGFyZHdhcmUvZWljb24vbWVzc2FnZS5jCmluZGV4IDBiMzgwNjAuLmQ3YzI4NjYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaXNkbi9oYXJkd2FyZS9laWNvbi9tZXNzYWdlLmMKKysrIGIvZHJpdmVycy9pc2RuL2hhcmR3YXJlL2VpY29uL21lc3NhZ2UuYwpAQCAtMTQ3NCw3ICsxNDc0LDcgQEAKIAkJCQkJYWRkX2FpKHBsY2ksICZwYXJtc1s1XSk7CiAJCQkJCXNpZ19yZXEocGxjaSwgUkVKRUNULCAwKTsKIAkJCQl9Ci0JCQkJZWxzZSBpZiAoUmVqZWN0ID09IDEgfHwgUmVqZWN0ID4gOSkKKwkJCQllbHNlIGlmIChSZWplY3QgPT0gMSB8fCBSZWplY3QgPj0gOSkKIAkJCQl7CiAJCQkJCWFkZF9haShwbGNpLCAmcGFybXNbNV0pOwogCQkJCQlzaWdfcmVxKHBsY2ksIEhBTkdVUCwgMCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21haWxib3gvcGNjLmMgYi9kcml2ZXJzL21haWxib3gvcGNjLmMKaW5kZXggNmRiZjZmYy4uZTg5MDJmOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tYWlsYm94L3BjYy5jCisrKyBiL2RyaXZlcnMvbWFpbGJveC9wY2MuYwpAQCAtMzg2LDcgKzM4Niw3IEBACiAJcmV0ID0gYWNwaV9wY2NfcHJvYmUoKTsKIAogCWlmIChyZXQpIHsKLQkJcHJfZXJyKCJBQ1BJIFBDQyBwcm9iZSBmYWlsZWQuXG4iKTsKKwkJcHJfZGVidWcoIkFDUEkgUENDIHByb2JlIGZhaWxlZC5cbiIpOwogCQlyZXR1cm4gLUVOT0RFVjsKIAl9CiAKQEAgLTM5NCw3ICszOTQsNyBAQAogCQkJcGNjX21ib3hfcHJvYmUsIE5VTEwsIDAsIE5VTEwsIDApOwogCiAJaWYgKCFwY2NfcGRldikgewotCQlwcl9lcnIoIkVyciBjcmVhdGluZyBQQ0MgcGxhdGZvcm0gYnVuZGxlXG4iKTsKKwkJcHJfZGVidWcoIkVyciBjcmVhdGluZyBQQ0MgcGxhdGZvcm0gYnVuZGxlXG4iKTsKIAkJcmV0dXJuIC1FTk9ERVY7CiAJfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL2JpdG1hcC5jIGIvZHJpdmVycy9tZC9iaXRtYXAuYwppbmRleCBkYTM2MDRlLi4xNjk1ZWU1IDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL2JpdG1hcC5jCisrKyBiL2RyaXZlcnMvbWQvYml0bWFwLmMKQEAgLTcyLDYgKzcyLDE5IEBACiAJLyogdGhpcyBwYWdlIGhhcyBub3QgYmVlbiBhbGxvY2F0ZWQgeWV0ICovCiAKIAlzcGluX3VubG9ja19pcnEoJmJpdG1hcC0+bG9jayk7CisJLyogSXQgaXMgcG9zc2libGUgdGhhdCB0aGlzIGlzIGJlaW5nIGNhbGxlZCBpbnNpZGUgYQorCSAqIHByZXBhcmVfdG9fd2FpdC9maW5pc2hfd2FpdCBsb29wIGZyb20gcmFpZDVjOm1ha2VfcmVxdWVzdCgpLgorCSAqIEluIGdlbmVyYWwgaXQgaXMgbm90IHBlcm1pdHRlZCB0byBzbGVlcCBpbiB0aGF0IGNvbnRleHQgYXMgaXQKKwkgKiBjYW4gY2F1c2UgdGhlIGxvb3AgdG8gc3BpbiBmcmVlbHkuCisJICogVGhhdCBkb2Vzbid0IGFwcGx5IGhlcmUgYXMgd2UgY2FuIG9ubHkgcmVhY2ggdGhpcyBwb2ludAorCSAqIG9uY2Ugd2l0aCBhbnkgbG9vcC4KKwkgKiBXaGVuIHRoaXMgZnVuY3Rpb24gY29tcGxldGVzLCBlaXRoZXIgYnBbcGFnZV0ubWFwIG9yCisJICogYnBbcGFnZV0uaGlqYWNrZWQuICBJbiBlaXRoZXIgY2FzZSwgdGhpcyBmdW5jdGlvbiB3aWxsCisJICogYWJvcnQgYmVmb3JlIGdldHRpbmcgdG8gdGhpcyBwb2ludCBhZ2Fpbi4gIFNvIHRoZXJlIGlzCisJICogbm8gcmlzayBvZiBhIGZyZWUtc3BpbiwgYW5kIHNvIGl0IGlzIHNhZmUgdG8gYXNzZXJ0CisJICogdGhhdCBzbGVlcGluZyBoZXJlIGlzIGFsbG93ZWQuCisJICovCisJc2NoZWRfYW5ub3RhdGVfc2xlZXAoKTsKIAltYXBwYWdlID0ga3phbGxvYyhQQUdFX1NJWkUsIEdGUF9OT0lPKTsKIAlzcGluX2xvY2tfaXJxKCZiaXRtYXAtPmxvY2spOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL2RtLWNhY2hlLW1ldGFkYXRhLmMgYi9kcml2ZXJzL21kL2RtLWNhY2hlLW1ldGFkYXRhLmMKaW5kZXggOWZjNjE2Yy4uYzFjMDEwNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZC9kbS1jYWNoZS1tZXRhZGF0YS5jCisrKyBiL2RyaXZlcnMvbWQvZG0tY2FjaGUtbWV0YWRhdGEuYwpAQCAtOTQsNiArOTQsOSBAQAogfSBfX3BhY2tlZDsKIAogc3RydWN0IGRtX2NhY2hlX21ldGFkYXRhIHsKKwlhdG9taWNfdCByZWZfY291bnQ7CisJc3RydWN0IGxpc3RfaGVhZCBsaXN0OworCiAJc3RydWN0IGJsb2NrX2RldmljZSAqYmRldjsKIAlzdHJ1Y3QgZG1fYmxvY2tfbWFuYWdlciAqYm07CiAJc3RydWN0IGRtX3NwYWNlX21hcCAqbWV0YWRhdGFfc207CkBAIC02NjksMTAgKzY3MiwxMCBAQAogCiAvKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwogCi1zdHJ1Y3QgZG1fY2FjaGVfbWV0YWRhdGEgKmRtX2NhY2hlX21ldGFkYXRhX29wZW4oc3RydWN0IGJsb2NrX2RldmljZSAqYmRldiwKLQkJCQkJCSBzZWN0b3JfdCBkYXRhX2Jsb2NrX3NpemUsCi0JCQkJCQkgYm9vbCBtYXlfZm9ybWF0X2RldmljZSwKLQkJCQkJCSBzaXplX3QgcG9saWN5X2hpbnRfc2l6ZSkKK3N0YXRpYyBzdHJ1Y3QgZG1fY2FjaGVfbWV0YWRhdGEgKm1ldGFkYXRhX29wZW4oc3RydWN0IGJsb2NrX2RldmljZSAqYmRldiwKKwkJCQkJICAgICAgIHNlY3Rvcl90IGRhdGFfYmxvY2tfc2l6ZSwKKwkJCQkJICAgICAgIGJvb2wgbWF5X2Zvcm1hdF9kZXZpY2UsCisJCQkJCSAgICAgICBzaXplX3QgcG9saWN5X2hpbnRfc2l6ZSkKIHsKIAlpbnQgcjsKIAlzdHJ1Y3QgZG1fY2FjaGVfbWV0YWRhdGEgKmNtZDsKQEAgLTY4MCw5ICs2ODMsMTAgQEAKIAljbWQgPSBremFsbG9jKHNpemVvZigqY21kKSwgR0ZQX0tFUk5FTCk7CiAJaWYgKCFjbWQpIHsKIAkJRE1FUlIoImNvdWxkIG5vdCBhbGxvY2F0ZSBtZXRhZGF0YSBzdHJ1Y3QiKTsKLQkJcmV0dXJuIE5VTEw7CisJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOwogCX0KIAorCWF0b21pY19zZXQoJmNtZC0+cmVmX2NvdW50LCAxKTsKIAlpbml0X3J3c2VtKCZjbWQtPnJvb3RfbG9jayk7CiAJY21kLT5iZGV2ID0gYmRldjsKIAljbWQtPmRhdGFfYmxvY2tfc2l6ZSA9IGRhdGFfYmxvY2tfc2l6ZTsKQEAgLTcwNSwxMCArNzA5LDk2IEBACiAJcmV0dXJuIGNtZDsKIH0KIAorLyoKKyAqIFdlIGtlZXAgYSBsaXR0bGUgbGlzdCBvZiByZWYgY291bnRlZCBtZXRhZGF0YSBvYmplY3RzIHRvIHByZXZlbnQgdHdvCisgKiBkaWZmZXJlbnQgdGFyZ2V0IGluc3RhbmNlcyBjcmVhdGluZyBzZXBhcmF0ZSBidWZpbyBpbnN0YW5jZXMuICBUaGlzIGlzCisgKiBhbiBpc3N1ZSBpZiBhIHRhYmxlIGlzIHJlbG9hZGVkIGJlZm9yZSB0aGUgc3VzcGVuZC4KKyAqLworc3RhdGljIERFRklORV9NVVRFWCh0YWJsZV9sb2NrKTsKK3N0YXRpYyBMSVNUX0hFQUQodGFibGUpOworCitzdGF0aWMgc3RydWN0IGRtX2NhY2hlX21ldGFkYXRhICpsb29rdXAoc3RydWN0IGJsb2NrX2RldmljZSAqYmRldikKK3sKKwlzdHJ1Y3QgZG1fY2FjaGVfbWV0YWRhdGEgKmNtZDsKKworCWxpc3RfZm9yX2VhY2hfZW50cnkoY21kLCAmdGFibGUsIGxpc3QpCisJCWlmIChjbWQtPmJkZXYgPT0gYmRldikgeworCQkJYXRvbWljX2luYygmY21kLT5yZWZfY291bnQpOworCQkJcmV0dXJuIGNtZDsKKwkJfQorCisJcmV0dXJuIE5VTEw7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgZG1fY2FjaGVfbWV0YWRhdGEgKmxvb2t1cF9vcl9vcGVuKHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYsCisJCQkJCQlzZWN0b3JfdCBkYXRhX2Jsb2NrX3NpemUsCisJCQkJCQlib29sIG1heV9mb3JtYXRfZGV2aWNlLAorCQkJCQkJc2l6ZV90IHBvbGljeV9oaW50X3NpemUpCit7CisJc3RydWN0IGRtX2NhY2hlX21ldGFkYXRhICpjbWQsICpjbWQyOworCisJbXV0ZXhfbG9jaygmdGFibGVfbG9jayk7CisJY21kID0gbG9va3VwKGJkZXYpOworCW11dGV4X3VubG9jaygmdGFibGVfbG9jayk7CisKKwlpZiAoY21kKQorCQlyZXR1cm4gY21kOworCisJY21kID0gbWV0YWRhdGFfb3BlbihiZGV2LCBkYXRhX2Jsb2NrX3NpemUsIG1heV9mb3JtYXRfZGV2aWNlLCBwb2xpY3lfaGludF9zaXplKTsKKwlpZiAoIUlTX0VSUihjbWQpKSB7CisJCW11dGV4X2xvY2soJnRhYmxlX2xvY2spOworCQljbWQyID0gbG9va3VwKGJkZXYpOworCQlpZiAoY21kMikgeworCQkJbXV0ZXhfdW5sb2NrKCZ0YWJsZV9sb2NrKTsKKwkJCV9fZGVzdHJveV9wZXJzaXN0ZW50X2RhdGFfb2JqZWN0cyhjbWQpOworCQkJa2ZyZWUoY21kKTsKKwkJCXJldHVybiBjbWQyOworCQl9CisJCWxpc3RfYWRkKCZjbWQtPmxpc3QsICZ0YWJsZSk7CisJCW11dGV4X3VubG9jaygmdGFibGVfbG9jayk7CisJfQorCisJcmV0dXJuIGNtZDsKK30KKworc3RhdGljIGJvb2wgc2FtZV9wYXJhbXMoc3RydWN0IGRtX2NhY2hlX21ldGFkYXRhICpjbWQsIHNlY3Rvcl90IGRhdGFfYmxvY2tfc2l6ZSkKK3sKKwlpZiAoY21kLT5kYXRhX2Jsb2NrX3NpemUgIT0gZGF0YV9ibG9ja19zaXplKSB7CisJCURNRVJSKCJkYXRhX2Jsb2NrX3NpemUgKCVsbHUpIGRpZmZlcmVudCBmcm9tIHRoYXQgaW4gbWV0YWRhdGEgKCVsbHUpXG4iLAorCQkgICAgICAodW5zaWduZWQgbG9uZyBsb25nKSBkYXRhX2Jsb2NrX3NpemUsCisJCSAgICAgICh1bnNpZ25lZCBsb25nIGxvbmcpIGNtZC0+ZGF0YV9ibG9ja19zaXplKTsKKwkJcmV0dXJuIGZhbHNlOworCX0KKworCXJldHVybiB0cnVlOworfQorCitzdHJ1Y3QgZG1fY2FjaGVfbWV0YWRhdGEgKmRtX2NhY2hlX21ldGFkYXRhX29wZW4oc3RydWN0IGJsb2NrX2RldmljZSAqYmRldiwKKwkJCQkJCSBzZWN0b3JfdCBkYXRhX2Jsb2NrX3NpemUsCisJCQkJCQkgYm9vbCBtYXlfZm9ybWF0X2RldmljZSwKKwkJCQkJCSBzaXplX3QgcG9saWN5X2hpbnRfc2l6ZSkKK3sKKwlzdHJ1Y3QgZG1fY2FjaGVfbWV0YWRhdGEgKmNtZCA9IGxvb2t1cF9vcl9vcGVuKGJkZXYsIGRhdGFfYmxvY2tfc2l6ZSwKKwkJCQkJCSAgICAgICBtYXlfZm9ybWF0X2RldmljZSwgcG9saWN5X2hpbnRfc2l6ZSk7CisKKwlpZiAoIUlTX0VSUihjbWQpICYmICFzYW1lX3BhcmFtcyhjbWQsIGRhdGFfYmxvY2tfc2l6ZSkpIHsKKwkJZG1fY2FjaGVfbWV0YWRhdGFfY2xvc2UoY21kKTsKKwkJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7CisJfQorCisJcmV0dXJuIGNtZDsKK30KKwogdm9pZCBkbV9jYWNoZV9tZXRhZGF0YV9jbG9zZShzdHJ1Y3QgZG1fY2FjaGVfbWV0YWRhdGEgKmNtZCkKIHsKLQlfX2Rlc3Ryb3lfcGVyc2lzdGVudF9kYXRhX29iamVjdHMoY21kKTsKLQlrZnJlZShjbWQpOworCWlmIChhdG9taWNfZGVjX2FuZF90ZXN0KCZjbWQtPnJlZl9jb3VudCkpIHsKKwkJbXV0ZXhfbG9jaygmdGFibGVfbG9jayk7CisJCWxpc3RfZGVsKCZjbWQtPmxpc3QpOworCQltdXRleF91bmxvY2soJnRhYmxlX2xvY2spOworCisJCV9fZGVzdHJveV9wZXJzaXN0ZW50X2RhdGFfb2JqZWN0cyhjbWQpOworCQlrZnJlZShjbWQpOworCX0KIH0KIAogLyoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWQvZG0tY2FjaGUtdGFyZ2V0LmMgYi9kcml2ZXJzL21kL2RtLWNhY2hlLXRhcmdldC5jCmluZGV4IDFlOTZkNzguLmUxNjUwNTMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvZG0tY2FjaGUtdGFyZ2V0LmMKKysrIGIvZHJpdmVycy9tZC9kbS1jYWNoZS10YXJnZXQuYwpAQCAtMjIxLDcgKzIyMSwxMyBAQAogCXN0cnVjdCBsaXN0X2hlYWQgbmVlZF9jb21taXRfbWlncmF0aW9uczsKIAlzZWN0b3JfdCBtaWdyYXRpb25fdGhyZXNob2xkOwogCXdhaXRfcXVldWVfaGVhZF90IG1pZ3JhdGlvbl93YWl0OwotCWF0b21pY190IG5yX21pZ3JhdGlvbnM7CisJYXRvbWljX3QgbnJfYWxsb2NhdGVkX21pZ3JhdGlvbnM7CisKKwkvKgorCSAqIFRoZSBudW1iZXIgb2YgaW4gZmxpZ2h0IG1pZ3JhdGlvbnMgdGhhdCBhcmUgcGVyZm9ybWluZworCSAqIGJhY2tncm91bmQgaW8uIGVnLCBwcm9tb3Rpb24sIHdyaXRlYmFjay4KKwkgKi8KKwlhdG9taWNfdCBucl9pb19taWdyYXRpb25zOwogCiAJd2FpdF9xdWV1ZV9oZWFkX3QgcXVpZXNjaW5nX3dhaXQ7CiAJYXRvbWljX3QgcXVpZXNjaW5nOwpAQCAtMjU4LDcgKzI2NCw2IEBACiAJc3RydWN0IGRtX2RlZmVycmVkX3NldCAqYWxsX2lvX2RzOwogCiAJbWVtcG9vbF90ICptaWdyYXRpb25fcG9vbDsKLQlzdHJ1Y3QgZG1fY2FjaGVfbWlncmF0aW9uICpuZXh0X21pZ3JhdGlvbjsKIAogCXN0cnVjdCBkbV9jYWNoZV9wb2xpY3kgKnBvbGljeTsKIAl1bnNpZ25lZCBwb2xpY3lfbnJfYXJnczsKQEAgLTM1MCwxMCArMzU1LDMxIEBACiAJZG1fYmlvX3ByaXNvbl9mcmVlX2NlbGwoY2FjaGUtPnByaXNvbiwgY2VsbCk7CiB9CiAKK3N0YXRpYyBzdHJ1Y3QgZG1fY2FjaGVfbWlncmF0aW9uICphbGxvY19taWdyYXRpb24oc3RydWN0IGNhY2hlICpjYWNoZSkKK3sKKwlzdHJ1Y3QgZG1fY2FjaGVfbWlncmF0aW9uICptZzsKKworCW1nID0gbWVtcG9vbF9hbGxvYyhjYWNoZS0+bWlncmF0aW9uX3Bvb2wsIEdGUF9OT1dBSVQpOworCWlmIChtZykgeworCQltZy0+Y2FjaGUgPSBjYWNoZTsKKwkJYXRvbWljX2luYygmbWctPmNhY2hlLT5ucl9hbGxvY2F0ZWRfbWlncmF0aW9ucyk7CisJfQorCisJcmV0dXJuIG1nOworfQorCitzdGF0aWMgdm9pZCBmcmVlX21pZ3JhdGlvbihzdHJ1Y3QgZG1fY2FjaGVfbWlncmF0aW9uICptZykKK3sKKwlpZiAoYXRvbWljX2RlY19hbmRfdGVzdCgmbWctPmNhY2hlLT5ucl9hbGxvY2F0ZWRfbWlncmF0aW9ucykpCisJCXdha2VfdXAoJm1nLT5jYWNoZS0+bWlncmF0aW9uX3dhaXQpOworCisJbWVtcG9vbF9mcmVlKG1nLCBtZy0+Y2FjaGUtPm1pZ3JhdGlvbl9wb29sKTsKK30KKwogc3RhdGljIGludCBwcmVhbGxvY19kYXRhX3N0cnVjdHMoc3RydWN0IGNhY2hlICpjYWNoZSwgc3RydWN0IHByZWFsbG9jICpwKQogewogCWlmICghcC0+bWcpIHsKLQkJcC0+bWcgPSBtZW1wb29sX2FsbG9jKGNhY2hlLT5taWdyYXRpb25fcG9vbCwgR0ZQX05PV0FJVCk7CisJCXAtPm1nID0gYWxsb2NfbWlncmF0aW9uKGNhY2hlKTsKIAkJaWYgKCFwLT5tZykKIAkJCXJldHVybiAtRU5PTUVNOwogCX0KQEAgLTM4Miw3ICs0MDgsNyBAQAogCQlmcmVlX3ByaXNvbl9jZWxsKGNhY2hlLCBwLT5jZWxsMSk7CiAKIAlpZiAocC0+bWcpCi0JCW1lbXBvb2xfZnJlZShwLT5tZywgY2FjaGUtPm1pZ3JhdGlvbl9wb29sKTsKKwkJZnJlZV9taWdyYXRpb24ocC0+bWcpOwogfQogCiBzdGF0aWMgc3RydWN0IGRtX2NhY2hlX21pZ3JhdGlvbiAqcHJlYWxsb2NfZ2V0X21pZ3JhdGlvbihzdHJ1Y3QgcHJlYWxsb2MgKnApCkBAIC04NTQsMjQgKzg4MCwxNCBAQAogICogTWlncmF0aW9uIGNvdmVycyBtb3ZpbmcgZGF0YSBmcm9tIHRoZSBvcmlnaW4gZGV2aWNlIHRvIHRoZSBjYWNoZSwgb3IKICAqIHZpY2UgdmVyc2EuCiAgKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KLXN0YXRpYyB2b2lkIGZyZWVfbWlncmF0aW9uKHN0cnVjdCBkbV9jYWNoZV9taWdyYXRpb24gKm1nKQorc3RhdGljIHZvaWQgaW5jX2lvX21pZ3JhdGlvbnMoc3RydWN0IGNhY2hlICpjYWNoZSkKIHsKLQltZW1wb29sX2ZyZWUobWcsIG1nLT5jYWNoZS0+bWlncmF0aW9uX3Bvb2wpOworCWF0b21pY19pbmMoJmNhY2hlLT5ucl9pb19taWdyYXRpb25zKTsKIH0KIAotc3RhdGljIHZvaWQgaW5jX25yX21pZ3JhdGlvbnMoc3RydWN0IGNhY2hlICpjYWNoZSkKK3N0YXRpYyB2b2lkIGRlY19pb19taWdyYXRpb25zKHN0cnVjdCBjYWNoZSAqY2FjaGUpCiB7Ci0JYXRvbWljX2luYygmY2FjaGUtPm5yX21pZ3JhdGlvbnMpOwotfQotCi1zdGF0aWMgdm9pZCBkZWNfbnJfbWlncmF0aW9ucyhzdHJ1Y3QgY2FjaGUgKmNhY2hlKQotewotCWF0b21pY19kZWMoJmNhY2hlLT5ucl9taWdyYXRpb25zKTsKLQotCS8qCi0JICogV2FrZSB0aGUgd29ya2VyIGluIGNhc2Ugd2UncmUgc3VzcGVuZGluZyB0aGUgdGFyZ2V0LgotCSAqLwotCXdha2VfdXAoJmNhY2hlLT5taWdyYXRpb25fd2FpdCk7CisJYXRvbWljX2RlYygmY2FjaGUtPm5yX2lvX21pZ3JhdGlvbnMpOwogfQogCiBzdGF0aWMgdm9pZCBfX2NlbGxfZGVmZXIoc3RydWN0IGNhY2hlICpjYWNoZSwgc3RydWN0IGRtX2Jpb19wcmlzb25fY2VsbCAqY2VsbCwKQEAgLTg5NCwxMSArOTEwLDEwIEBACiAJd2FrZV93b3JrZXIoY2FjaGUpOwogfQogCi1zdGF0aWMgdm9pZCBjbGVhbnVwX21pZ3JhdGlvbihzdHJ1Y3QgZG1fY2FjaGVfbWlncmF0aW9uICptZykKK3N0YXRpYyB2b2lkIGZyZWVfaW9fbWlncmF0aW9uKHN0cnVjdCBkbV9jYWNoZV9taWdyYXRpb24gKm1nKQogewotCXN0cnVjdCBjYWNoZSAqY2FjaGUgPSBtZy0+Y2FjaGU7CisJZGVjX2lvX21pZ3JhdGlvbnMobWctPmNhY2hlKTsKIAlmcmVlX21pZ3JhdGlvbihtZyk7Ci0JZGVjX25yX21pZ3JhdGlvbnMoY2FjaGUpOwogfQogCiBzdGF0aWMgdm9pZCBtaWdyYXRpb25fZmFpbHVyZShzdHJ1Y3QgZG1fY2FjaGVfbWlncmF0aW9uICptZykKQEAgLTkyMyw3ICs5MzgsNyBAQAogCQljZWxsX2RlZmVyKGNhY2hlLCBtZy0+bmV3X29jZWxsLCB0cnVlKTsKIAl9CiAKLQljbGVhbnVwX21pZ3JhdGlvbihtZyk7CisJZnJlZV9pb19taWdyYXRpb24obWcpOwogfQogCiBzdGF0aWMgdm9pZCBtaWdyYXRpb25fc3VjY2Vzc19wcmVfY29tbWl0KHN0cnVjdCBkbV9jYWNoZV9taWdyYXRpb24gKm1nKQpAQCAtOTM0LDcgKzk0OSw3IEBACiAJaWYgKG1nLT53cml0ZWJhY2spIHsKIAkJY2xlYXJfZGlydHkoY2FjaGUsIG1nLT5vbGRfb2Jsb2NrLCBtZy0+Y2Jsb2NrKTsKIAkJY2VsbF9kZWZlcihjYWNoZSwgbWctPm9sZF9vY2VsbCwgZmFsc2UpOwotCQljbGVhbnVwX21pZ3JhdGlvbihtZyk7CisJCWZyZWVfaW9fbWlncmF0aW9uKG1nKTsKIAkJcmV0dXJuOwogCiAJfSBlbHNlIGlmIChtZy0+ZGVtb3RlKSB7CkBAIC05NDQsMTQgKzk1OSwxNCBAQAogCQkJCQkgICAgIG1nLT5vbGRfb2Jsb2NrKTsKIAkJCWlmIChtZy0+cHJvbW90ZSkKIAkJCQljZWxsX2RlZmVyKGNhY2hlLCBtZy0+bmV3X29jZWxsLCB0cnVlKTsKLQkJCWNsZWFudXBfbWlncmF0aW9uKG1nKTsKKwkJCWZyZWVfaW9fbWlncmF0aW9uKG1nKTsKIAkJCXJldHVybjsKIAkJfQogCX0gZWxzZSB7CiAJCWlmIChkbV9jYWNoZV9pbnNlcnRfbWFwcGluZyhjYWNoZS0+Y21kLCBtZy0+Y2Jsb2NrLCBtZy0+bmV3X29ibG9jaykpIHsKIAkJCURNV0FSTl9MSU1JVCgicHJvbW90aW9uIGZhaWxlZDsgY291bGRuJ3QgdXBkYXRlIG9uIGRpc2sgbWV0YWRhdGEiKTsKIAkJCXBvbGljeV9yZW1vdmVfbWFwcGluZyhjYWNoZS0+cG9saWN5LCBtZy0+bmV3X29ibG9jayk7Ci0JCQljbGVhbnVwX21pZ3JhdGlvbihtZyk7CisJCQlmcmVlX2lvX21pZ3JhdGlvbihtZyk7CiAJCQlyZXR1cm47CiAJCX0KIAl9CkBAIC05ODQsNyArOTk5LDcgQEAKIAkJfSBlbHNlIHsKIAkJCWlmIChtZy0+aW52YWxpZGF0ZSkKIAkJCQlwb2xpY3lfcmVtb3ZlX21hcHBpbmcoY2FjaGUtPnBvbGljeSwgbWctPm9sZF9vYmxvY2spOwotCQkJY2xlYW51cF9taWdyYXRpb24obWcpOworCQkJZnJlZV9pb19taWdyYXRpb24obWcpOwogCQl9CiAKIAl9IGVsc2UgewpAQCAtOTk5LDcgKzEwMTQsNyBAQAogCQkJYmlvX2VuZGlvKG1nLT5uZXdfb2NlbGwtPmhvbGRlciwgMCk7CiAJCQljZWxsX2RlZmVyKGNhY2hlLCBtZy0+bmV3X29jZWxsLCBmYWxzZSk7CiAJCX0KLQkJY2xlYW51cF9taWdyYXRpb24obWcpOworCQlmcmVlX2lvX21pZ3JhdGlvbihtZyk7CiAJfQogfQogCkBAIC0xMjUxLDcgKzEyNjYsNyBAQAogCW1nLT5uZXdfb2NlbGwgPSBjZWxsOwogCW1nLT5zdGFydF9qaWZmaWVzID0gamlmZmllczsKIAotCWluY19ucl9taWdyYXRpb25zKGNhY2hlKTsKKwlpbmNfaW9fbWlncmF0aW9ucyhjYWNoZSk7CiAJcXVpZXNjZV9taWdyYXRpb24obWcpOwogfQogCkBAIC0xMjc1LDcgKzEyOTAsNyBAQAogCW1nLT5uZXdfb2NlbGwgPSBOVUxMOwogCW1nLT5zdGFydF9qaWZmaWVzID0gamlmZmllczsKIAotCWluY19ucl9taWdyYXRpb25zKGNhY2hlKTsKKwlpbmNfaW9fbWlncmF0aW9ucyhjYWNoZSk7CiAJcXVpZXNjZV9taWdyYXRpb24obWcpOwogfQogCkBAIC0xMzAyLDcgKzEzMTcsNyBAQAogCW1nLT5uZXdfb2NlbGwgPSBuZXdfb2NlbGw7CiAJbWctPnN0YXJ0X2ppZmZpZXMgPSBqaWZmaWVzOwogCi0JaW5jX25yX21pZ3JhdGlvbnMoY2FjaGUpOworCWluY19pb19taWdyYXRpb25zKGNhY2hlKTsKIAlxdWllc2NlX21pZ3JhdGlvbihtZyk7CiB9CiAKQEAgLTEzMzAsNyArMTM0NSw3IEBACiAJbWctPm5ld19vY2VsbCA9IE5VTEw7CiAJbWctPnN0YXJ0X2ppZmZpZXMgPSBqaWZmaWVzOwogCi0JaW5jX25yX21pZ3JhdGlvbnMoY2FjaGUpOworCWluY19pb19taWdyYXRpb25zKGNhY2hlKTsKIAlxdWllc2NlX21pZ3JhdGlvbihtZyk7CiB9CiAKQEAgLTE0MTIsNyArMTQyNyw3IEBACiAKIHN0YXRpYyBib29sIHNwYXJlX21pZ3JhdGlvbl9iYW5kd2lkdGgoc3RydWN0IGNhY2hlICpjYWNoZSkKIHsKLQlzZWN0b3JfdCBjdXJyZW50X3ZvbHVtZSA9IChhdG9taWNfcmVhZCgmY2FjaGUtPm5yX21pZ3JhdGlvbnMpICsgMSkgKgorCXNlY3Rvcl90IGN1cnJlbnRfdm9sdW1lID0gKGF0b21pY19yZWFkKCZjYWNoZS0+bnJfaW9fbWlncmF0aW9ucykgKyAxKSAqCiAJCWNhY2hlLT5zZWN0b3JzX3Blcl9ibG9jazsKIAlyZXR1cm4gY3VycmVudF92b2x1bWUgPCBjYWNoZS0+bWlncmF0aW9uX3RocmVzaG9sZDsKIH0KQEAgLTE3NjQsNyArMTc3OSw3IEBACiAKIHN0YXRpYyB2b2lkIHdhaXRfZm9yX21pZ3JhdGlvbnMoc3RydWN0IGNhY2hlICpjYWNoZSkKIHsKLQl3YWl0X2V2ZW50KGNhY2hlLT5taWdyYXRpb25fd2FpdCwgIWF0b21pY19yZWFkKCZjYWNoZS0+bnJfbWlncmF0aW9ucykpOworCXdhaXRfZXZlbnQoY2FjaGUtPm1pZ3JhdGlvbl93YWl0LCAhYXRvbWljX3JlYWQoJmNhY2hlLT5ucl9hbGxvY2F0ZWRfbWlncmF0aW9ucykpOwogfQogCiBzdGF0aWMgdm9pZCBzdG9wX3dvcmtlcihzdHJ1Y3QgY2FjaGUgKmNhY2hlKQpAQCAtMTg3Niw5ICsxODkxLDYgQEAKIHsKIAl1bnNpZ25lZCBpOwogCi0JaWYgKGNhY2hlLT5uZXh0X21pZ3JhdGlvbikKLQkJbWVtcG9vbF9mcmVlKGNhY2hlLT5uZXh0X21pZ3JhdGlvbiwgY2FjaGUtPm1pZ3JhdGlvbl9wb29sKTsKLQogCWlmIChjYWNoZS0+bWlncmF0aW9uX3Bvb2wpCiAJCW1lbXBvb2xfZGVzdHJveShjYWNoZS0+bWlncmF0aW9uX3Bvb2wpOwogCkBAIC0yNDI0LDcgKzI0MzYsOCBAQAogCUlOSVRfTElTVF9IRUFEKCZjYWNoZS0+cXVpZXNjZWRfbWlncmF0aW9ucyk7CiAJSU5JVF9MSVNUX0hFQUQoJmNhY2hlLT5jb21wbGV0ZWRfbWlncmF0aW9ucyk7CiAJSU5JVF9MSVNUX0hFQUQoJmNhY2hlLT5uZWVkX2NvbW1pdF9taWdyYXRpb25zKTsKLQlhdG9taWNfc2V0KCZjYWNoZS0+bnJfbWlncmF0aW9ucywgMCk7CisJYXRvbWljX3NldCgmY2FjaGUtPm5yX2FsbG9jYXRlZF9taWdyYXRpb25zLCAwKTsKKwlhdG9taWNfc2V0KCZjYWNoZS0+bnJfaW9fbWlncmF0aW9ucywgMCk7CiAJaW5pdF93YWl0cXVldWVfaGVhZCgmY2FjaGUtPm1pZ3JhdGlvbl93YWl0KTsKIAogCWluaXRfd2FpdHF1ZXVlX2hlYWQoJmNhY2hlLT5xdWllc2Npbmdfd2FpdCk7CkBAIC0yNDg3LDggKzI1MDAsNiBAQAogCQlnb3RvIGJhZDsKIAl9CiAKLQljYWNoZS0+bmV4dF9taWdyYXRpb24gPSBOVUxMOwotCiAJY2FjaGUtPm5lZWRfdGlja19iaW8gPSB0cnVlOwogCWNhY2hlLT5zaXplZCA9IGZhbHNlOwogCWNhY2hlLT5pbnZhbGlkYXRlID0gZmFsc2U7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL2RtLXRoaW4uYyBiL2RyaXZlcnMvbWQvZG0tdGhpbi5jCmluZGV4IDQ5MzQ3ODkuLjA3NzA1ZWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvZG0tdGhpbi5jCisrKyBiL2RyaXZlcnMvbWQvZG0tdGhpbi5jCkBAIC0zMzg1LDYgKzMzODUsMTIgQEAKIAlzdHJ1Y3QgcG9vbF9jICpwdCA9IHRpLT5wcml2YXRlOwogCXN0cnVjdCBwb29sICpwb29sID0gcHQtPnBvb2w7CiAKKwlpZiAoZ2V0X3Bvb2xfbW9kZShwb29sKSA+PSBQTV9SRUFEX09OTFkpIHsKKwkJRE1FUlIoIiVzOiB1bmFibGUgdG8gc2VydmljZSBwb29sIHRhcmdldCBtZXNzYWdlcyBpbiBSRUFEX09OTFkgb3IgRkFJTCBtb2RlIiwKKwkJICAgICAgZG1fZGV2aWNlX25hbWUocG9vbC0+cG9vbF9tZCkpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKIAlpZiAoIXN0cmNhc2VjbXAoYXJndlswXSwgImNyZWF0ZV90aGluIikpCiAJCXIgPSBwcm9jZXNzX2NyZWF0ZV90aGluX21lc2coYXJnYywgYXJndiwgcG9vbCk7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWQvZG0uYyBiL2RyaXZlcnMvbWQvZG0uYwppbmRleCBiOThjZDlkLi4yY2FmNWIzIDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL2RtLmMKKysrIGIvZHJpdmVycy9tZC9kbS5jCkBAIC0yMDYsNiArMjA2LDkgQEAKIAkvKiB6ZXJvLWxlbmd0aCBmbHVzaCB0aGF0IHdpbGwgYmUgY2xvbmVkIGFuZCBzdWJtaXR0ZWQgdG8gdGFyZ2V0cyAqLwogCXN0cnVjdCBiaW8gZmx1c2hfYmlvOwogCisJLyogdGhlIG51bWJlciBvZiBpbnRlcm5hbCBzdXNwZW5kcyAqLworCXVuc2lnbmVkIGludGVybmFsX3N1c3BlbmRfY291bnQ7CisKIAlzdHJ1Y3QgZG1fc3RhdHMgc3RhdHM7CiB9OwogCkBAIC0yOTI4LDcgKzI5MzEsNyBAQAogewogCXN0cnVjdCBkbV90YWJsZSAqbWFwID0gTlVMTDsKIAotCWlmIChkbV9zdXNwZW5kZWRfaW50ZXJuYWxseV9tZChtZCkpCisJaWYgKG1kLT5pbnRlcm5hbF9zdXNwZW5kX2NvdW50KyspCiAJCXJldHVybjsgLyogbmVzdGVkIGludGVybmFsIHN1c3BlbmQgKi8KIAogCWlmIChkbV9zdXNwZW5kZWRfbWQobWQpKSB7CkBAIC0yOTUzLDcgKzI5NTYsOSBAQAogCiBzdGF0aWMgdm9pZCBfX2RtX2ludGVybmFsX3Jlc3VtZShzdHJ1Y3QgbWFwcGVkX2RldmljZSAqbWQpCiB7Ci0JaWYgKCFkbV9zdXNwZW5kZWRfaW50ZXJuYWxseV9tZChtZCkpCisJQlVHX09OKCFtZC0+aW50ZXJuYWxfc3VzcGVuZF9jb3VudCk7CisKKwlpZiAoLS1tZC0+aW50ZXJuYWxfc3VzcGVuZF9jb3VudCkKIAkJcmV0dXJuOyAvKiByZXN1bWUgZnJvbSBuZXN0ZWQgaW50ZXJuYWwgc3VzcGVuZCAqLwogCiAJaWYgKGRtX3N1c3BlbmRlZF9tZChtZCkpCmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL3JhaWQ1LmMgYi9kcml2ZXJzL21kL3JhaWQ1LmMKaW5kZXggYzFiMGQ1Mi4uYjk4NzY1ZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZC9yYWlkNS5jCisrKyBiL2RyaXZlcnMvbWQvcmFpZDUuYwpAQCAtMzE5NSw2ICszMTk1LDExIEBACiAJCQkJCSAgKHVuc2lnbmVkIGxvbmcgbG9uZylzaC0+c2VjdG9yLAogCQkJCQkgIHJjdywgcXJlYWQsIHRlc3RfYml0KFNUUklQRV9ERUxBWUVELCAmc2gtPnN0YXRlKSk7CiAJfQorCisJaWYgKHJjdyA+IGRpc2tzICYmIHJtdyA+IGRpc2tzICYmCisJICAgICF0ZXN0X2JpdChTVFJJUEVfUFJFUkVBRF9BQ1RJVkUsICZzaC0+c3RhdGUpKQorCQlzZXRfYml0KFNUUklQRV9ERUxBWUVELCAmc2gtPnN0YXRlKTsKKwogCS8qIG5vdyBpZiBub3RoaW5nIGlzIGxvY2tlZCwgYW5kIGlmIHdlIGhhdmUgZW5vdWdoIGRhdGEsCiAJICogd2UgY2FuIHN0YXJ0IGEgd3JpdGUgcmVxdWVzdAogCSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9wY2kvY3gyMzg4NS9jeDIzODg1LWNhcmRzLmMgYi9kcml2ZXJzL21lZGlhL3BjaS9jeDIzODg1L2N4MjM4ODUtY2FyZHMuYwppbmRleCBkYjk5Y2EyLi4wNjkzMWY2IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3BjaS9jeDIzODg1L2N4MjM4ODUtY2FyZHMuYworKysgYi9kcml2ZXJzL21lZGlhL3BjaS9jeDIzODg1L2N4MjM4ODUtY2FyZHMuYwpAQCAtNjE0LDcgKzYxNCw3IEBACiAJCS5wb3J0YgkJPSBDWDIzODg1X01QRUdfRFZCLAogCX0sCiAJW0NYMjM4ODVfQk9BUkRfSEFVUFBBVUdFX0hWUjQ0MDBdID0gewotCQkubmFtZQkJPSAiSGF1cHBhdWdlIFdpblRWLUhWUjQ0MDAiLAorCQkubmFtZQkJPSAiSGF1cHBhdWdlIFdpblRWLUhWUjQ0MDAvSFZSNTUwMCIsCiAJCS5wb3J0YQkJPSBDWDIzODg1X0FOQUxPR19WSURFTywKIAkJLnBvcnRiCQk9IENYMjM4ODVfTVBFR19EVkIsCiAJCS5wb3J0YwkJPSBDWDIzODg1X01QRUdfRFZCLApAQCAtNjIyLDYgKzYyMiwxMCBAQAogCQkudHVuZXJfYWRkcgk9IDB4NjAsIC8qIDB4YzAgPj4gMSAqLwogCQkudHVuZXJfYnVzCT0gMSwKIAl9LAorCVtDWDIzODg1X0JPQVJEX0hBVVBQQVVHRV9TVEFSQlVSU1RdID0geworCQkubmFtZQkJPSAiSGF1cHBhdWdlIFdpblRWIFN0YXJidXJzdCIsCisJCS5wb3J0YgkJPSBDWDIzODg1X01QRUdfRFZCLAorCX0sCiAJW0NYMjM4ODVfQk9BUkRfQVZFUk1FRElBX0hDODFSXSA9IHsKIAkJLm5hbWUJCT0gIkFWZXJUViBIeWJyaWQgRXhwcmVzcyBTbGltIEhDODFSIiwKIAkJLnR1bmVyX3R5cGUJPSBUVU5FUl9YQzIwMjgsCkBAIC05MzYsMTkgKzk0MCwxOSBAQAogCX0sIHsKIAkJLnN1YnZlbmRvciA9IDB4MDA3MCwKIAkJLnN1YmRldmljZSA9IDB4YzEwOCwKLQkJLmNhcmQgICAgICA9IENYMjM4ODVfQk9BUkRfSEFVUFBBVUdFX0hWUjQ0MDAsCisJCS5jYXJkICAgICAgPSBDWDIzODg1X0JPQVJEX0hBVVBQQVVHRV9IVlI0NDAwLCAvKiBIYXVwcGF1Z2UgV2luVFYgSFZSLTQ0MDAgKE1vZGVsIDEyMXh4eCwgSHlicmlkIERWQi1UL1MyLCBJUikgKi8KIAl9LCB7CiAJCS5zdWJ2ZW5kb3IgPSAweDAwNzAsCiAJCS5zdWJkZXZpY2UgPSAweGMxMzgsCi0JCS5jYXJkICAgICAgPSBDWDIzODg1X0JPQVJEX0hBVVBQQVVHRV9IVlI0NDAwLAorCQkuY2FyZCAgICAgID0gQ1gyMzg4NV9CT0FSRF9IQVVQUEFVR0VfSFZSNDQwMCwgLyogSGF1cHBhdWdlIFdpblRWIEhWUi01NTAwIChNb2RlbCAxMjF4eHgsIEh5YnJpZCBEVkItVC9DL1MyLCBJUikgKi8KIAl9LCB7CiAJCS5zdWJ2ZW5kb3IgPSAweDAwNzAsCiAJCS5zdWJkZXZpY2UgPSAweGMxMmEsCi0JCS5jYXJkICAgICAgPSBDWDIzODg1X0JPQVJEX0hBVVBQQVVHRV9IVlI0NDAwLAorCQkuY2FyZCAgICAgID0gQ1gyMzg4NV9CT0FSRF9IQVVQUEFVR0VfU1RBUkJVUlNULCAvKiBIYXVwcGF1Z2UgV2luVFYgU3RhcmJ1cnN0IChNb2RlbCAxMjF4MDAsIERWQi1TMiwgSVIpICovCiAJfSwgewogCQkuc3VidmVuZG9yID0gMHgwMDcwLAogCQkuc3ViZGV2aWNlID0gMHhjMWY4LAotCQkuY2FyZCAgICAgID0gQ1gyMzg4NV9CT0FSRF9IQVVQUEFVR0VfSFZSNDQwMCwKKwkJLmNhcmQgICAgICA9IENYMjM4ODVfQk9BUkRfSEFVUFBBVUdFX0hWUjQ0MDAsIC8qIEhhdXBwYXVnZSBXaW5UViBIVlItNTUwMCAoTW9kZWwgMTIxeHh4LCBIeWJyaWQgRFZCLVQvQy9TMiwgSVIpICovCiAJfSwgewogCQkuc3VidmVuZG9yID0gMHgxNDYxLAogCQkuc3ViZGV2aWNlID0gMHhkOTM5LApAQCAtMTU0NSw4ICsxNTQ5LDkgQEAKIAkJY3hfd3JpdGUoR1BJT19JU00sIDB4MDAwMDAwMDApOy8qIElOVEVSUlVQVFMgYWN0aXZlIGxvdyovCiAJCWJyZWFrOwogCWNhc2UgQ1gyMzg4NV9CT0FSRF9IQVVQUEFVR0VfSFZSNDQwMDoKKwljYXNlIENYMjM4ODVfQk9BUkRfSEFVUFBBVUdFX1NUQVJCVVJTVDoKIAkJLyogR1BJTy04IHRkYTEwMDcxIGRlbW9kIHJlc2V0ICovCi0JCS8qIEdQSU8tOSBzaTIxNjUgZGVtb2QgcmVzZXQgKi8KKwkJLyogR1BJTy05IHNpMjE2NSBkZW1vZCByZXNldCAob25seSBIVlI0NDAwL0hWUjU1MDApKi8KIAogCQkvKiBQdXQgdGhlIHBhcnRzIGludG8gcmVzZXQgYW5kIGJhY2sgKi8KIAkJY3gyMzg4NV9ncGlvX2VuYWJsZShkZXYsIEdQSU9fOCB8IEdQSU9fOSwgMSk7CkBAIC0xODcyLDYgKzE4NzcsNyBAQAogCWNhc2UgQ1gyMzg4NV9CT0FSRF9IQVVQUEFVR0VfSFZSMTg1MDoKIAljYXNlIENYMjM4ODVfQk9BUkRfSEFVUFBBVUdFX0hWUjEyOTA6CiAJY2FzZSBDWDIzODg1X0JPQVJEX0hBVVBQQVVHRV9IVlI0NDAwOgorCWNhc2UgQ1gyMzg4NV9CT0FSRF9IQVVQUEFVR0VfU1RBUkJVUlNUOgogCWNhc2UgQ1gyMzg4NV9CT0FSRF9IQVVQUEFVR0VfSU1QQUNUVkNCRToKIAkJaWYgKGRldi0+aTJjX2J1c1swXS5pMmNfcmMgPT0gMCkKIAkJCWhhdXBwYXVnZV9lZXByb20oZGV2LCBlZXByb20rMHhjMCk7CkBAIC0xOTgwLDYgKzE5ODYsMTEgQEAKIAkJdHMyLT50c19jbGtfZW5fdmFsID0gMHgxOyAvKiBFbmFibGUgVFNfQ0xLICovCiAJCXRzMi0+c3JjX3NlbF92YWwgICA9IENYMjM4ODVfU1JDX1NFTF9QQVJBTExFTF9NUEVHX1ZJREVPOwogCQlicmVhazsKKwljYXNlIENYMjM4ODVfQk9BUkRfSEFVUFBBVUdFX1NUQVJCVVJTVDoKKwkJdHMxLT5nZW5fY3RybF92YWwgID0gMHhjOyAvKiBTZXJpYWwgYnVzICsgcHVuY3R1cmVkIGNsb2NrICovCisJCXRzMS0+dHNfY2xrX2VuX3ZhbCA9IDB4MTsgLyogRW5hYmxlIFRTX0NMSyAqLworCQl0czEtPnNyY19zZWxfdmFsICAgPSBDWDIzODg1X1NSQ19TRUxfUEFSQUxMRUxfTVBFR19WSURFTzsKKwkJYnJlYWs7CiAJY2FzZSBDWDIzODg1X0JPQVJEX0RWQlNLWV9UOTU4MDoKIAljYXNlIENYMjM4ODVfQk9BUkRfRFZCU0tZX1Q5ODI6CiAJCXRzMS0+Z2VuX2N0cmxfdmFsICA9IDB4NTsgLyogUGFyYWxsZWwgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcGNpL2N4MjM4ODUvY3gyMzg4NS1jb3JlLmMgYi9kcml2ZXJzL21lZGlhL3BjaS9jeDIzODg1L2N4MjM4ODUtY29yZS5jCmluZGV4IDFkOWQwZjguLjFhZDQ5OTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvcGNpL2N4MjM4ODUvY3gyMzg4NS1jb3JlLmMKKysrIGIvZHJpdmVycy9tZWRpYS9wY2kvY3gyMzg4NS9jeDIzODg1LWNvcmUuYwpAQCAtMjA0OSwxMSArMjA0OSwxMSBAQAogCiAJY3gyMzg4NV9zaHV0ZG93bihkZXYpOwogCi0JcGNpX2Rpc2FibGVfZGV2aWNlKHBjaV9kZXYpOwotCiAJLyogdW5yZWdpc3RlciBzdHVmZiAqLwogCWZyZWVfaXJxKHBjaV9kZXYtPmlycSwgZGV2KTsKIAorCXBjaV9kaXNhYmxlX2RldmljZShwY2lfZGV2KTsKKwogCWN4MjM4ODVfZGV2X3VucmVnaXN0ZXIoZGV2KTsKIAl2YjJfZG1hX3NnX2NsZWFudXBfY3R4KGRldi0+YWxsb2NfY3R4KTsKIAl2NGwyX2N0cmxfaGFuZGxlcl9mcmVlKCZkZXYtPmN0cmxfaGFuZGxlcik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3BjaS9jeDIzODg1L2N4MjM4ODUtZHZiLmMgYi9kcml2ZXJzL21lZGlhL3BjaS9jeDIzODg1L2N4MjM4ODUtZHZiLmMKaW5kZXggYzQ3ZDE4Mi4uYTljNDUwZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9wY2kvY3gyMzg4NS9jeDIzODg1LWR2Yi5jCisrKyBiL2RyaXZlcnMvbWVkaWEvcGNpL2N4MjM4ODUvY3gyMzg4NS1kdmIuYwpAQCAtMTcxMCw2ICsxNzEwLDE3IEBACiAJCQlicmVhazsKIAkJfQogCQlicmVhazsKKwljYXNlIENYMjM4ODVfQk9BUkRfSEFVUFBBVUdFX1NUQVJCVVJTVDoKKwkJaTJjX2J1cyA9ICZkZXYtPmkyY19idXNbMF07CisJCWZlMC0+ZHZiLmZyb250ZW5kID0gZHZiX2F0dGFjaCh0ZGExMDA3MV9hdHRhY2gsCisJCQkJCQkmaGF1cHBhdWdlX3RkYTEwMDcxX2NvbmZpZywKKwkJCQkJCSZpMmNfYnVzLT5pMmNfYWRhcCk7CisJCWlmIChmZTAtPmR2Yi5mcm9udGVuZCAhPSBOVUxMKSB7CisJCQlkdmJfYXR0YWNoKGE4MjkzX2F0dGFjaCwgZmUwLT5kdmIuZnJvbnRlbmQsCisJCQkJICAgJmkyY19idXMtPmkyY19hZGFwLAorCQkJCSAgICZoYXVwcGF1Z2VfYTgyOTNfY29uZmlnKTsKKwkJfQorCQlicmVhazsKIAljYXNlIENYMjM4ODVfQk9BUkRfRFZCU0tZX1Q5NTgwOgogCWNhc2UgQ1gyMzg4NV9CT0FSRF9EVkJTS1lfUzk1MDoKIAkJaTJjX2J1cyA9ICZkZXYtPmkyY19idXNbMF07CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3BjaS9jeDIzODg1L2N4MjM4ODUuaCBiL2RyaXZlcnMvbWVkaWEvcGNpL2N4MjM4ODUvY3gyMzg4NS5oCmluZGV4IGY1NWNkMTIuLjM2ZjJmOTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvcGNpL2N4MjM4ODUvY3gyMzg4NS5oCisrKyBiL2RyaXZlcnMvbWVkaWEvcGNpL2N4MjM4ODUvY3gyMzg4NS5oCkBAIC05OSw2ICs5OSw3IEBACiAjZGVmaW5lIENYMjM4ODVfQk9BUkRfRFZCU0tZX1M5NTAgICAgICAgICAgICAgIDQ5CiAjZGVmaW5lIENYMjM4ODVfQk9BUkRfRFZCU0tZX1M5NTIgICAgICAgICAgICAgIDUwCiAjZGVmaW5lIENYMjM4ODVfQk9BUkRfRFZCU0tZX1Q5ODIgICAgICAgICAgICAgIDUxCisjZGVmaW5lIENYMjM4ODVfQk9BUkRfSEFVUFBBVUdFX1NUQVJCVVJTVCAgICAgIDUyCiAKICNkZWZpbmUgR1BJT18wIDB4MDAwMDAwMDEKICNkZWZpbmUgR1BJT18xIDB4MDAwMDAwMDIKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vb21hcDNpc3AvaXNwdmlkZW8uYyBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vb21hcDNpc3AvaXNwdmlkZW8uYwppbmRleCBiNDYzZmUxLi4zZmU5MDQ3IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL29tYXAzaXNwL2lzcHZpZGVvLmMKKysrIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9vbWFwM2lzcC9pc3B2aWRlby5jCkBAIC02MDIsMTAgKzYwMiwxMyBAQAogCXN0cmxjcHkoY2FwLT5jYXJkLCB2aWRlby0+dmlkZW8ubmFtZSwgc2l6ZW9mKGNhcC0+Y2FyZCkpOwogCXN0cmxjcHkoY2FwLT5idXNfaW5mbywgIm1lZGlhIiwgc2l6ZW9mKGNhcC0+YnVzX2luZm8pKTsKIAorCWNhcC0+Y2FwYWJpbGl0aWVzID0gVjRMMl9DQVBfVklERU9fQ0FQVFVSRSB8IFY0TDJfQ0FQX1ZJREVPX09VVFBVVAorCQl8IFY0TDJfQ0FQX1NUUkVBTUlORyB8IFY0TDJfQ0FQX0RFVklDRV9DQVBTOworCiAJaWYgKHZpZGVvLT50eXBlID09IFY0TDJfQlVGX1RZUEVfVklERU9fQ0FQVFVSRSkKLQkJY2FwLT5jYXBhYmlsaXRpZXMgPSBWNEwyX0NBUF9WSURFT19DQVBUVVJFIHwgVjRMMl9DQVBfU1RSRUFNSU5HOworCQljYXAtPmRldmljZV9jYXBzID0gVjRMMl9DQVBfVklERU9fQ0FQVFVSRSB8IFY0TDJfQ0FQX1NUUkVBTUlORzsKIAllbHNlCi0JCWNhcC0+Y2FwYWJpbGl0aWVzID0gVjRMMl9DQVBfVklERU9fT1VUUFVUIHwgVjRMMl9DQVBfU1RSRUFNSU5HOworCQljYXAtPmRldmljZV9jYXBzID0gVjRMMl9DQVBfVklERU9fT1VUUFVUIHwgVjRMMl9DQVBfU1RSRUFNSU5HOwogCiAJcmV0dXJuIDA7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3NvY19jYW1lcmEvYXRtZWwtaXNpLmMgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3NvY19jYW1lcmEvYXRtZWwtaXNpLmMKaW5kZXggOGVmZTQwMy4uNmQ4ODUyMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9zb2NfY2FtZXJhL2F0bWVsLWlzaS5jCisrKyBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vc29jX2NhbWVyYS9hdG1lbC1pc2kuYwpAQCAtNzYwLDggKzc2MCw5IEBACiB7CiAJc3RyY3B5KGNhcC0+ZHJpdmVyLCAiYXRtZWwtaXNpIik7CiAJc3RyY3B5KGNhcC0+Y2FyZCwgIkF0bWVsIEltYWdlIFNlbnNvciBJbnRlcmZhY2UiKTsKLQljYXAtPmNhcGFiaWxpdGllcyA9IChWNEwyX0NBUF9WSURFT19DQVBUVVJFIHwKLQkJCQlWNEwyX0NBUF9TVFJFQU1JTkcpOworCWNhcC0+ZGV2aWNlX2NhcHMgPSBWNEwyX0NBUF9WSURFT19DQVBUVVJFIHwgVjRMMl9DQVBfU1RSRUFNSU5HOworCWNhcC0+Y2FwYWJpbGl0aWVzID0gY2FwLT5kZXZpY2VfY2FwcyB8IFY0TDJfQ0FQX0RFVklDRV9DQVBTOworCiAJcmV0dXJuIDA7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vc29jX2NhbWVyYS9teDJfY2FtZXJhLmMgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3NvY19jYW1lcmEvbXgyX2NhbWVyYS5jCmluZGV4IGNlNzJiZDIuLjE5MjM3N2YgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vc29jX2NhbWVyYS9teDJfY2FtZXJhLmMKKysrIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9zb2NfY2FtZXJhL214Ml9jYW1lcmEuYwpAQCAtMTI1Niw3ICsxMjU2LDggQEAKIHsKIAkvKiBjYXAtPm5hbWUgaXMgc2V0IGJ5IHRoZSBmcmllbmRseSBjYWxsZXI6LT4gKi8KIAlzdHJsY3B5KGNhcC0+Y2FyZCwgTVgyX0NBTV9EUklWRVJfREVTQ1JJUFRJT04sIHNpemVvZihjYXAtPmNhcmQpKTsKLQljYXAtPmNhcGFiaWxpdGllcyA9IFY0TDJfQ0FQX1ZJREVPX0NBUFRVUkUgfCBWNEwyX0NBUF9TVFJFQU1JTkc7CisJY2FwLT5kZXZpY2VfY2FwcyA9IFY0TDJfQ0FQX1ZJREVPX0NBUFRVUkUgfCBWNEwyX0NBUF9TVFJFQU1JTkc7CisJY2FwLT5jYXBhYmlsaXRpZXMgPSBjYXAtPmRldmljZV9jYXBzIHwgVjRMMl9DQVBfREVWSUNFX0NBUFM7CiAKIAlyZXR1cm4gMDsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vc29jX2NhbWVyYS9teDNfY2FtZXJhLmMgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3NvY19jYW1lcmEvbXgzX2NhbWVyYS5jCmluZGV4IGE2MGMzYmIuLjBiMzI5OWQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vc29jX2NhbWVyYS9teDNfY2FtZXJhLmMKKysrIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9zb2NfY2FtZXJhL214M19jYW1lcmEuYwpAQCAtOTY3LDcgKzk2Nyw4IEBACiB7CiAJLyogY2FwLT5uYW1lIGlzIHNldCBieSB0aGUgZmlyZW5kbHkgY2FsbGVyOi0+ICovCiAJc3RybGNweShjYXAtPmNhcmQsICJpLk1YM3ggQ2FtZXJhIiwgc2l6ZW9mKGNhcC0+Y2FyZCkpOwotCWNhcC0+Y2FwYWJpbGl0aWVzID0gVjRMMl9DQVBfVklERU9fQ0FQVFVSRSB8IFY0TDJfQ0FQX1NUUkVBTUlORzsKKwljYXAtPmRldmljZV9jYXBzID0gVjRMMl9DQVBfVklERU9fQ0FQVFVSRSB8IFY0TDJfQ0FQX1NUUkVBTUlORzsKKwljYXAtPmNhcGFiaWxpdGllcyA9IGNhcC0+ZGV2aWNlX2NhcHMgfCBWNEwyX0NBUF9ERVZJQ0VfQ0FQUzsKIAogCXJldHVybiAwOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9zb2NfY2FtZXJhL29tYXAxX2NhbWVyYS5jIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9zb2NfY2FtZXJhL29tYXAxX2NhbWVyYS5jCmluZGV4IGU2YjkzMjguLjE2ZjY1ZWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vc29jX2NhbWVyYS9vbWFwMV9jYW1lcmEuYworKysgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3NvY19jYW1lcmEvb21hcDFfY2FtZXJhLmMKQEAgLTE0MjcsNyArMTQyNyw4IEBACiB7CiAJLyogY2FwLT5uYW1lIGlzIHNldCBieSB0aGUgZnJpZW5kbHkgY2FsbGVyOi0+ICovCiAJc3RybGNweShjYXAtPmNhcmQsICJPTUFQMSBDYW1lcmEiLCBzaXplb2YoY2FwLT5jYXJkKSk7Ci0JY2FwLT5jYXBhYmlsaXRpZXMgPSBWNEwyX0NBUF9WSURFT19DQVBUVVJFIHwgVjRMMl9DQVBfU1RSRUFNSU5HOworCWNhcC0+ZGV2aWNlX2NhcHMgPSBWNEwyX0NBUF9WSURFT19DQVBUVVJFIHwgVjRMMl9DQVBfU1RSRUFNSU5HOworCWNhcC0+Y2FwYWJpbGl0aWVzID0gY2FwLT5kZXZpY2VfY2FwcyB8IFY0TDJfQ0FQX0RFVklDRV9DQVBTOwogCiAJcmV0dXJuIDA7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3NvY19jYW1lcmEvcHhhX2NhbWVyYS5jIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9zb2NfY2FtZXJhL3B4YV9jYW1lcmEuYwppbmRleCA5NTEyMjZhLi44ZDZlMzQzIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3NvY19jYW1lcmEvcHhhX2NhbWVyYS5jCisrKyBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vc29jX2NhbWVyYS9weGFfY2FtZXJhLmMKQEAgLTE1NzYsNyArMTU3Niw4IEBACiB7CiAJLyogY2FwLT5uYW1lIGlzIHNldCBieSB0aGUgZmlyZW5kbHkgY2FsbGVyOi0+ICovCiAJc3RybGNweShjYXAtPmNhcmQsIHB4YV9jYW1fZHJpdmVyX2Rlc2NyaXB0aW9uLCBzaXplb2YoY2FwLT5jYXJkKSk7Ci0JY2FwLT5jYXBhYmlsaXRpZXMgPSBWNEwyX0NBUF9WSURFT19DQVBUVVJFIHwgVjRMMl9DQVBfU1RSRUFNSU5HOworCWNhcC0+ZGV2aWNlX2NhcHMgPSBWNEwyX0NBUF9WSURFT19DQVBUVVJFIHwgVjRMMl9DQVBfU1RSRUFNSU5HOworCWNhcC0+Y2FwYWJpbGl0aWVzID0gY2FwLT5kZXZpY2VfY2FwcyB8IFY0TDJfQ0FQX0RFVklDRV9DQVBTOwogCiAJcmV0dXJuIDA7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3NvY19jYW1lcmEvcmNhcl92aW4uYyBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vc29jX2NhbWVyYS9yY2FyX3Zpbi5jCmluZGV4IDBjMWY1NTYuLjlmMTQ3M2MgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vc29jX2NhbWVyYS9yY2FyX3Zpbi5jCisrKyBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vc29jX2NhbWVyYS9yY2FyX3Zpbi5jCkBAIC0xNzk5LDcgKzE3OTksOSBAQAogCQkJICAgICBzdHJ1Y3QgdjRsMl9jYXBhYmlsaXR5ICpjYXApCiB7CiAJc3RybGNweShjYXAtPmNhcmQsICJSX0Nhcl9WSU4iLCBzaXplb2YoY2FwLT5jYXJkKSk7Ci0JY2FwLT5jYXBhYmlsaXRpZXMgPSBWNEwyX0NBUF9WSURFT19DQVBUVVJFIHwgVjRMMl9DQVBfU1RSRUFNSU5HOworCWNhcC0+ZGV2aWNlX2NhcHMgPSBWNEwyX0NBUF9WSURFT19DQVBUVVJFIHwgVjRMMl9DQVBfU1RSRUFNSU5HOworCWNhcC0+Y2FwYWJpbGl0aWVzID0gY2FwLT5kZXZpY2VfY2FwcyB8IFY0TDJfQ0FQX0RFVklDRV9DQVBTOworCiAJcmV0dXJuIDA7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vc29jX2NhbWVyYS9zaF9tb2JpbGVfY2V1X2NhbWVyYS5jIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9zb2NfY2FtZXJhL3NoX21vYmlsZV9jZXVfY2FtZXJhLmMKaW5kZXggOGIyN2IzZS4uNzE3ODc3MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9zb2NfY2FtZXJhL3NoX21vYmlsZV9jZXVfY2FtZXJhLmMKKysrIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9zb2NfY2FtZXJhL3NoX21vYmlsZV9jZXVfY2FtZXJhLmMKQEAgLTE2NTIsNyArMTY1Miw5IEBACiAJCQkJICBzdHJ1Y3QgdjRsMl9jYXBhYmlsaXR5ICpjYXApCiB7CiAJc3RybGNweShjYXAtPmNhcmQsICJTdXBlckhfTW9iaWxlX0NFVSIsIHNpemVvZihjYXAtPmNhcmQpKTsKLQljYXAtPmNhcGFiaWxpdGllcyA9IFY0TDJfQ0FQX1ZJREVPX0NBUFRVUkUgfCBWNEwyX0NBUF9TVFJFQU1JTkc7CisJY2FwLT5kZXZpY2VfY2FwcyA9IFY0TDJfQ0FQX1ZJREVPX0NBUFRVUkUgfCBWNEwyX0NBUF9TVFJFQU1JTkc7CisJY2FwLT5jYXBhYmlsaXRpZXMgPSBjYXAtPmRldmljZV9jYXBzIHwgVjRMMl9DQVBfREVWSUNFX0NBUFM7CisKIAlyZXR1cm4gMDsKIH0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS91c2IvZHZiLXVzYi9jeHVzYi5jIGIvZHJpdmVycy9tZWRpYS91c2IvZHZiLXVzYi9jeHVzYi5jCmluZGV4IDBmMzQ1YjEuLmYzMjdjNDkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdXNiL2R2Yi11c2IvY3h1c2IuYworKysgYi9kcml2ZXJzL21lZGlhL3VzYi9kdmItdXNiL2N4dXNiLmMKQEAgLTIyMzIsNyArMjIzMiw3IEBACiAJCXsKIAkJCSJNeWdpY2EgVDIzMCBEVkItVC9UMi9DIiwKIAkJCXsgTlVMTCB9LAotCQkJeyAmY3h1c2JfdGFibGVbMjJdLCBOVUxMIH0sCisJCQl7ICZjeHVzYl90YWJsZVsyMF0sIE5VTEwgfSwKIAkJfSwKIAl9CiB9OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS91c2IvcHZydXNiMi9wdnJ1c2IyLXY0bDIuYyBiL2RyaXZlcnMvbWVkaWEvdXNiL3B2cnVzYjIvcHZydXNiMi12NGwyLmMKaW5kZXggMWIxNThmMS4uNTM2MjEwYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS91c2IvcHZydXNiMi9wdnJ1c2IyLXY0bDIuYworKysgYi9kcml2ZXJzL21lZGlhL3VzYi9wdnJ1c2IyL3B2cnVzYjItdjRsMi5jCkBAIC04OSwxNiArODksNiBAQAogbW9kdWxlX3BhcmFtX2FycmF5KHZiaV9uciwgaW50LCBOVUxMLCAwNDQ0KTsKIE1PRFVMRV9QQVJNX0RFU0ModmJpX25yLCAiT2Zmc2V0IGZvciBkZXZpY2UncyB2YmkgZGV2IG1pbm9yIik7CiAKLXN0YXRpYyBzdHJ1Y3QgdjRsMl9jYXBhYmlsaXR5IHB2cl9jYXBhYmlsaXR5ID17Ci0JLmRyaXZlciAgICAgICAgID0gInB2cnVzYjIiLAotCS5jYXJkICAgICAgICAgICA9ICJIYXVwcGF1Z2UgV2luVFYgcHZyLXVzYjIiLAotCS5idXNfaW5mbyAgICAgICA9ICJ1c2IiLAotCS52ZXJzaW9uICAgICAgICA9IExJTlVYX1ZFUlNJT05fQ09ERSwKLQkuY2FwYWJpbGl0aWVzICAgPSAoVjRMMl9DQVBfVklERU9fQ0FQVFVSRSB8Ci0JCQkgICBWNEwyX0NBUF9UVU5FUiB8IFY0TDJfQ0FQX0FVRElPIHwgVjRMMl9DQVBfUkFESU8gfAotCQkJICAgVjRMMl9DQVBfUkVBRFdSSVRFKSwKLX07Ci0KIHN0YXRpYyBzdHJ1Y3QgdjRsMl9mbXRkZXNjIHB2cl9mbXRkZXNjIFtdID0gewogCXsKIAkJLmluZGV4ICAgICAgICAgID0gMCwKQEAgLTE2MCwxMCArMTUwLDIyIEBACiAJc3RydWN0IHB2cjJfdjRsMl9maCAqZmggPSBmaWxlLT5wcml2YXRlX2RhdGE7CiAJc3RydWN0IHB2cjJfaGR3ICpoZHcgPSBmaC0+Y2hhbm5lbC5tY19oZWFkLT5oZHc7CiAKLQltZW1jcHkoY2FwLCAmcHZyX2NhcGFiaWxpdHksIHNpemVvZihzdHJ1Y3QgdjRsMl9jYXBhYmlsaXR5KSk7CisJc3RybGNweShjYXAtPmRyaXZlciwgInB2cnVzYjIiLCBzaXplb2YoY2FwLT5kcml2ZXIpKTsKIAlzdHJsY3B5KGNhcC0+YnVzX2luZm8sIHB2cjJfaGR3X2dldF9idXNfaW5mbyhoZHcpLAogCQkJc2l6ZW9mKGNhcC0+YnVzX2luZm8pKTsKIAlzdHJsY3B5KGNhcC0+Y2FyZCwgcHZyMl9oZHdfZ2V0X2Rlc2MoaGR3KSwgc2l6ZW9mKGNhcC0+Y2FyZCkpOworCWNhcC0+Y2FwYWJpbGl0aWVzID0gVjRMMl9DQVBfVklERU9fQ0FQVFVSRSB8IFY0TDJfQ0FQX1RVTkVSIHwKKwkJCSAgICBWNEwyX0NBUF9BVURJTyB8IFY0TDJfQ0FQX1JBRElPIHwKKwkJCSAgICBWNEwyX0NBUF9SRUFEV1JJVEUgfCBWNEwyX0NBUF9ERVZJQ0VfQ0FQUzsKKwlzd2l0Y2ggKGZoLT5wZGktPmRldmJhc2UudmZsX3R5cGUpIHsKKwljYXNlIFZGTF9UWVBFX0dSQUJCRVI6CisJCWNhcC0+ZGV2aWNlX2NhcHMgPSBWNEwyX0NBUF9WSURFT19DQVBUVVJFIHwgVjRMMl9DQVBfQVVESU87CisJCWJyZWFrOworCWNhc2UgVkZMX1RZUEVfUkFESU86CisJCWNhcC0+ZGV2aWNlX2NhcHMgPSBWNEwyX0NBUF9SQURJTzsKKwkJYnJlYWs7CisJfQorCWNhcC0+ZGV2aWNlX2NhcHMgfD0gVjRMMl9DQVBfVFVORVIgfCBWNEwyX0NBUF9SRUFEV1JJVEU7CiAJcmV0dXJuIDA7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdjRsMi1jb3JlL3ZpZGVvYnVmMi1jb3JlLmMgYi9kcml2ZXJzL21lZGlhL3Y0bDItY29yZS92aWRlb2J1ZjItY29yZS5jCmluZGV4IGQwOWE4OTEuLmJjMDhhODIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdjRsMi1jb3JlL3ZpZGVvYnVmMi1jb3JlLmMKKysrIGIvZHJpdmVycy9tZWRpYS92NGwyLWNvcmUvdmlkZW9idWYyLWNvcmUuYwpAQCAtMzE0NiwyNyArMzE0NiwyNiBAQAogCQkJcHJlcXVldWUtLTsKIAkJfSBlbHNlIHsKIAkJCWNhbGxfdm9pZF9xb3AocSwgd2FpdF9maW5pc2gsIHEpOwotCQkJcmV0ID0gdmIyX2ludGVybmFsX2RxYnVmKHEsICZmaWxlaW8tPmIsIDApOworCQkJaWYgKCF0aHJlYWRpby0+c3RvcCkKKwkJCQlyZXQgPSB2YjJfaW50ZXJuYWxfZHFidWYocSwgJmZpbGVpby0+YiwgMCk7CiAJCQljYWxsX3ZvaWRfcW9wKHEsIHdhaXRfcHJlcGFyZSwgcSk7CiAJCQlkcHJpbnRrKDUsICJmaWxlIGlvOiB2YjJfZHFidWYgcmVzdWx0OiAlZFxuIiwgcmV0KTsKIAkJfQotCQlpZiAodGhyZWFkaW8tPnN0b3ApCi0JCQlicmVhazsKLQkJaWYgKHJldCkKKwkJaWYgKHJldCB8fCB0aHJlYWRpby0+c3RvcCkKIAkJCWJyZWFrOwogCQl0cnlfdG9fZnJlZXplKCk7CiAKIAkJdmIgPSBxLT5idWZzW2ZpbGVpby0+Yi5pbmRleF07CiAJCWlmICghKGZpbGVpby0+Yi5mbGFncyAmIFY0TDJfQlVGX0ZMQUdfRVJST1IpKQotCQkJcmV0ID0gdGhyZWFkaW8tPmZuYyh2YiwgdGhyZWFkaW8tPnByaXYpOwotCQlpZiAocmV0KQotCQkJYnJlYWs7CisJCQlpZiAodGhyZWFkaW8tPmZuYyh2YiwgdGhyZWFkaW8tPnByaXYpKQorCQkJCWJyZWFrOwogCQljYWxsX3ZvaWRfcW9wKHEsIHdhaXRfZmluaXNoLCBxKTsKIAkJaWYgKHNldF90aW1lc3RhbXApCiAJCQl2NGwyX2dldF90aW1lc3RhbXAoJmZpbGVpby0+Yi50aW1lc3RhbXApOwotCQlyZXQgPSB2YjJfaW50ZXJuYWxfcWJ1ZihxLCAmZmlsZWlvLT5iKTsKKwkJaWYgKCF0aHJlYWRpby0+c3RvcCkKKwkJCXJldCA9IHZiMl9pbnRlcm5hbF9xYnVmKHEsICZmaWxlaW8tPmIpOwogCQljYWxsX3ZvaWRfcW9wKHEsIHdhaXRfcHJlcGFyZSwgcSk7Ci0JCWlmIChyZXQpCisJCWlmIChyZXQgfHwgdGhyZWFkaW8tPnN0b3ApCiAJCQlicmVhazsKIAl9CiAKQEAgLTMyMzUsMTEgKzMyMzQsMTEgQEAKIAl0aHJlYWRpby0+c3RvcCA9IHRydWU7CiAJdmIyX2ludGVybmFsX3N0cmVhbW9mZihxLCBxLT50eXBlKTsKIAljYWxsX3ZvaWRfcW9wKHEsIHdhaXRfcHJlcGFyZSwgcSk7CisJZXJyID0ga3RocmVhZF9zdG9wKHRocmVhZGlvLT50aHJlYWQpOwogCXEtPmZpbGVpbyA9IE5VTEw7CiAJZmlsZWlvLT5yZXEuY291bnQgPSAwOwogCXZiMl9yZXFidWZzKHEsICZmaWxlaW8tPnJlcSk7CiAJa2ZyZWUoZmlsZWlvKTsKLQllcnIgPSBrdGhyZWFkX3N0b3AodGhyZWFkaW8tPnRocmVhZCk7CiAJdGhyZWFkaW8tPnRocmVhZCA9IE5VTEw7CiAJa2ZyZWUodGhyZWFkaW8pOwogCXEtPmZpbGVpbyA9IE5VTEw7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21mZC9kYTkwNTItY29yZS5jIGIvZHJpdmVycy9tZmQvZGE5MDUyLWNvcmUuYwppbmRleCA1MmEwYzJmLi5hZTQ5OGI1IDEwMDY0NAotLS0gYS9kcml2ZXJzL21mZC9kYTkwNTItY29yZS5jCisrKyBiL2RyaXZlcnMvbWZkL2RhOTA1Mi1jb3JlLmMKQEAgLTU1NCw3ICs1NTQsOCBAQAogCQlyZXR1cm4gcmV0OwogCX0KIAotCXJldCA9IG1mZF9hZGRfZGV2aWNlcyhkYTkwNTItPmRldiwgLTEsIGRhOTA1Ml9zdWJkZXZfaW5mbywKKwlyZXQgPSBtZmRfYWRkX2RldmljZXMoZGE5MDUyLT5kZXYsIFBMQVRGT1JNX0RFVklEX0FVVE8sCisJCQkgICAgICBkYTkwNTJfc3ViZGV2X2luZm8sCiAJCQkgICAgICBBUlJBWV9TSVpFKGRhOTA1Ml9zdWJkZXZfaW5mbyksIE5VTEwsIDAsIE5VTEwpOwogCWlmIChyZXQpIHsKIAkJZGV2X2VycihkYTkwNTItPmRldiwgIm1mZF9hZGRfZGV2aWNlcyBmYWlsZWQ6ICVkXG4iLCByZXQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvcnRzeF91c2IuYyBiL2RyaXZlcnMvbWZkL3J0c3hfdXNiLmMKaW5kZXggZGJkZDBmYS4uMjEwZDFmOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZmQvcnRzeF91c2IuYworKysgYi9kcml2ZXJzL21mZC9ydHN4X3VzYi5jCkBAIC02ODEsMjEgKzY4MSw5IEBACiAjaWZkZWYgQ09ORklHX1BNCiBzdGF0aWMgaW50IHJ0c3hfdXNiX3N1c3BlbmQoc3RydWN0IHVzYl9pbnRlcmZhY2UgKmludGYsIHBtX21lc3NhZ2VfdCBtZXNzYWdlKQogewotCXN0cnVjdCBydHN4X3VjciAqdWNyID0KLQkJKHN0cnVjdCBydHN4X3VjciAqKXVzYl9nZXRfaW50ZmRhdGEoaW50Zik7Ci0KIAlkZXZfZGJnKCZpbnRmLT5kZXYsICIlcyBjYWxsZWQgd2l0aCBwbSBtZXNzYWdlIDB4JTA0eFxuIiwKIAkJCV9fZnVuY19fLCBtZXNzYWdlLmV2ZW50KTsKIAotCS8qCi0JICogQ2FsbCB0byBtYWtlIHN1cmUgTEVEIGlzIG9mZiBkdXJpbmcgc3VzcGVuZCB0byBzYXZlIG1vcmUgcG93ZXIuCi0JICogSXQgaXMgTk9UIGEgcGVybWFuZW50IHN0YXRlIGFuZCBjb3VsZCBiZSB0dXJuZWQgb24gYW55dGltZSBsYXRlci4KLQkgKiBUaHVzIG5vIG5lZWQgdG8gY2FsbCB0dXJuX29uIHdoZW4gcmVzdW5taW5nLgotCSAqLwotCW11dGV4X2xvY2soJnVjci0+ZGV2X211dGV4KTsKLQlydHN4X3VzYl90dXJuX29mZl9sZWQodWNyKTsKLQltdXRleF91bmxvY2soJnVjci0+ZGV2X211dGV4KTsKLQogCXJldHVybiAwOwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL21mZC90cHM2NTIxOC5jIGIvZHJpdmVycy9tZmQvdHBzNjUyMTguYwppbmRleCAwZDI1NmNiLi5kNmI3NjQzIDEwMDY0NAotLS0gYS9kcml2ZXJzL21mZC90cHM2NTIxOC5jCisrKyBiL2RyaXZlcnMvbWZkL3RwczY1MjE4LmMKQEAgLTEyNSwxMCArMTI1LDIxIEBACiB9CiBFWFBPUlRfU1lNQk9MX0dQTCh0cHM2NTIxOF9jbGVhcl9iaXRzKTsKIAorc3RhdGljIGNvbnN0IHN0cnVjdCByZWdtYXBfcmFuZ2UgdHBzNjUyMThfeWVzX3Jhbmdlc1tdID0geworCXJlZ21hcF9yZWdfcmFuZ2UoVFBTNjUyMThfUkVHX0lOVDEsIFRQUzY1MjE4X1JFR19JTlQyKSwKKwlyZWdtYXBfcmVnX3JhbmdlKFRQUzY1MjE4X1JFR19TVEFUVVMsIFRQUzY1MjE4X1JFR19TVEFUVVMpLAorfTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCByZWdtYXBfYWNjZXNzX3RhYmxlIHRwczY1MjE4X3ZvbGF0aWxlX3RhYmxlID0geworCS55ZXNfcmFuZ2VzID0gdHBzNjUyMThfeWVzX3JhbmdlcywKKwkubl95ZXNfcmFuZ2VzID0gQVJSQVlfU0laRSh0cHM2NTIxOF95ZXNfcmFuZ2VzKSwKK307CisKIHN0YXRpYyBzdHJ1Y3QgcmVnbWFwX2NvbmZpZyB0cHM2NTIxOF9yZWdtYXBfY29uZmlnID0gewogCS5yZWdfYml0cyA9IDgsCiAJLnZhbF9iaXRzID0gOCwKIAkuY2FjaGVfdHlwZSA9IFJFR0NBQ0hFX1JCVFJFRSwKKwkudm9sYXRpbGVfdGFibGUgPSAmdHBzNjUyMThfdm9sYXRpbGVfdGFibGUsCiB9OwogCiBzdGF0aWMgY29uc3Qgc3RydWN0IHJlZ21hcF9pcnEgdHBzNjUyMThfaXJxc1tdID0gewpAQCAtMTkzLDYgKzIwNCw3IEBACiAKIAkubnVtX3JlZ3MgPSAyLAogCS5tYXNrX2Jhc2UgPSBUUFM2NTIxOF9SRUdfSU5UX01BU0sxLAorCS5zdGF0dXNfYmFzZSA9IFRQUzY1MjE4X1JFR19JTlQxLAogfTsKIAogc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgb2ZfdHBzNjUyMThfbWF0Y2hfdGFibGVbXSA9IHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2NhaWYvY2FpZl9oc2kuYyBiL2RyaXZlcnMvbmV0L2NhaWYvY2FpZl9oc2kuYwppbmRleCA1ZTQwYThiLi5iM2I5MjJhIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9jYWlmL2NhaWZfaHNpLmMKKysrIGIvZHJpdmVycy9uZXQvY2FpZi9jYWlmX2hzaS5jCkBAIC0xNDE1LDcgKzE0MTUsNiBAQAogCiAJY2Zoc2kgPSBuZXRkZXZfcHJpdihkZXYpOwogCWNmaHNpX25ldGxpbmtfcGFybXMoZGF0YSwgY2Zoc2kpOwotCWRldl9uZXRfc2V0KGNmaHNpLT5uZGV2LCBzcmNfbmV0KTsKIAogCWdldF9vcHMgPSBzeW1ib2xfZ2V0KGNmaHNpX2dldF9vcHMpOwogCWlmICghZ2V0X29wcykgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvY2FuL2NfY2FuL2NfY2FuLmMgYi9kcml2ZXJzL25ldC9jYW4vY19jYW4vY19jYW4uYwppbmRleCBmOTRhOWZhLi5jNjcyYzRkIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9jYW4vY19jYW4vY19jYW4uYworKysgYi9kcml2ZXJzL25ldC9jYW4vY19jYW4vY19jYW4uYwpAQCAtNjE1LDYgKzYxNSw5IEBACiAKIAljX2Nhbl9pcnFfY29udHJvbChwcml2LCBmYWxzZSk7CiAKKwkvKiBwdXQgY3RybCB0byBpbml0IG9uIHN0b3AgdG8gZW5kIG9uZ29pbmcgdHJhbnNtaXNzaW9uICovCisJcHJpdi0+d3JpdGVfcmVnKHByaXYsIENfQ0FOX0NUUkxfUkVHLCBDT05UUk9MX0lOSVQpOworCiAJLyogZGVhY3RpdmF0ZSBwaW5zICovCiAJcGluY3RybF9wbV9zZWxlY3Rfc2xlZXBfc3RhdGUoZGV2LT5kZXYucGFyZW50KTsKIAlwcml2LT5jYW4uc3RhdGUgPSBDQU5fU1RBVEVfU1RPUFBFRDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2Nhbi9jX2Nhbi9jX2Nhbl9wbGF0Zm9ybS5jIGIvZHJpdmVycy9uZXQvY2FuL2NfY2FuL2NfY2FuX3BsYXRmb3JtLmMKaW5kZXggZjM2Mzk3Mi4uZTM2ZDEwNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvY2FuL2NfY2FuL2NfY2FuX3BsYXRmb3JtLmMKKysrIGIvZHJpdmVycy9uZXQvY2FuL2NfY2FuL2NfY2FuX3BsYXRmb3JtLmMKQEAgLTEwMywyNyArMTAzLDM0IEBACiAJbWFzayA9IDEgPDwgcmFtaW5pdC0+Yml0cy5zdGFydCB8IDEgPDwgcmFtaW5pdC0+Yml0cy5kb25lOwogCXJlZ21hcF9yZWFkKHJhbWluaXQtPnN5c2NvbiwgcmFtaW5pdC0+cmVnLCAmY3RybCk7CiAKLQkvKiBXZSBjbGVhciB0aGUgZG9uZSBhbmQgc3RhcnQgYml0IGZpcnN0LiBUaGUgc3RhcnQgYml0IGlzCisJLyogV2UgY2xlYXIgdGhlIHN0YXJ0IGJpdCBmaXJzdC4gVGhlIHN0YXJ0IGJpdCBpcwogCSAqIGxvb2tpbmcgYXQgdGhlIDAgLT4gdHJhbnNpdGlvbiwgYnV0IGlzIG5vdCBzZWxmIGNsZWFyaW5nOwotCSAqIEFuZCB3ZSBjbGVhciB0aGUgaW5pdCBkb25lIGJpdCBhcyB3ZWxsLgogCSAqIE5PVEU6IERPTkUgbXVzdCBiZSB3cml0dGVuIHdpdGggMSB0byBjbGVhciBpdC4KKwkgKiBXZSBjYW4ndCBjbGVhciB0aGUgRE9ORSBiaXQgaGVyZSB1c2luZyByZWdtYXBfdXBkYXRlX2JpdHMoKQorCSAqIGFzIGl0IHdpbGwgYnlwYXNzIHRoZSB3cml0ZSBpZiBpbml0aWFsIGNvbmRpdGlvbiBpcyBTVEFSVDowIERPTkU6MQorCSAqIGUuZy4gb24gRFJBNyB3aGljaCBuZWVkcyBTVEFSVCBwdWxzZS4KIAkgKi8KLQljdHJsICY9IH4oMSA8PCByYW1pbml0LT5iaXRzLnN0YXJ0KTsKLQljdHJsIHw9IDEgPDwgcmFtaW5pdC0+Yml0cy5kb25lOwotCXJlZ21hcF93cml0ZShyYW1pbml0LT5zeXNjb24sIHJhbWluaXQtPnJlZywgY3RybCk7CisJY3RybCAmPSB+bWFzazsJLyogU1RBUlQgPSAwLCBET05FID0gMCAqLworCXJlZ21hcF91cGRhdGVfYml0cyhyYW1pbml0LT5zeXNjb24sIHJhbWluaXQtPnJlZywgbWFzaywgY3RybCk7CiAKLQljdHJsICY9IH4oMSA8PCByYW1pbml0LT5iaXRzLmRvbmUpOwotCWNfY2FuX2h3X3JhbWluaXRfd2FpdF9zeXNjb24ocHJpdiwgbWFzaywgY3RybCk7CisJLyogY2hlY2sgaWYgU1RBUlQgYml0IGlzIDAuIElnbm9yZSBET05FIGJpdCBmb3Igbm93CisJICogYXMgaXQgY2FuIGJlIGVpdGhlciAwIG9yIDEuCisJICovCisJY19jYW5faHdfcmFtaW5pdF93YWl0X3N5c2Nvbihwcml2LCAxIDw8IHJhbWluaXQtPmJpdHMuc3RhcnQsIGN0cmwpOwogCiAJaWYgKGVuYWJsZSkgewotCQkvKiBTZXQgc3RhcnQgYml0IGFuZCB3YWl0IGZvciB0aGUgZG9uZSBiaXQuICovCisJCS8qIENsZWFyIERPTkUgYml0ICYgc2V0IFNUQVJUIGJpdC4gKi8KIAkJY3RybCB8PSAxIDw8IHJhbWluaXQtPmJpdHMuc3RhcnQ7Ci0JCXJlZ21hcF93cml0ZShyYW1pbml0LT5zeXNjb24sIHJhbWluaXQtPnJlZywgY3RybCk7Ci0KKwkJLyogRE9ORSBtdXN0IGJlIHdyaXR0ZW4gd2l0aCAxIHRvIGNsZWFyIGl0ICovCisJCWN0cmwgfD0gMSA8PCByYW1pbml0LT5iaXRzLmRvbmU7CisJCXJlZ21hcF91cGRhdGVfYml0cyhyYW1pbml0LT5zeXNjb24sIHJhbWluaXQtPnJlZywgbWFzaywgY3RybCk7CisJCS8qIHByZXZlbnQgZnVydGhlciBjbGVhcmluZyBvZiBET05FIGJpdCAqLworCQljdHJsICY9IH4oMSA8PCByYW1pbml0LT5iaXRzLmRvbmUpOwogCQkvKiBjbGVhciBTVEFSVCBiaXQgaWYgc3RhcnQgcHVsc2UgaXMgbmVlZGVkICovCiAJCWlmIChyYW1pbml0LT5uZWVkc19wdWxzZSkgewogCQkJY3RybCAmPSB+KDEgPDwgcmFtaW5pdC0+Yml0cy5zdGFydCk7Ci0JCQlyZWdtYXBfd3JpdGUocmFtaW5pdC0+c3lzY29uLCByYW1pbml0LT5yZWcsIGN0cmwpOworCQkJcmVnbWFwX3VwZGF0ZV9iaXRzKHJhbWluaXQtPnN5c2NvbiwgcmFtaW5pdC0+cmVnLAorCQkJCQkgICBtYXNrLCBjdHJsKTsKIAkJfQogCiAJCWN0cmwgfD0gMSA8PCByYW1pbml0LT5iaXRzLmRvbmU7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9jYW4vZGV2LmMgYi9kcml2ZXJzL25ldC9jYW4vZGV2LmMKaW5kZXggM2VjOGY2Zi4uODQ3YzFmOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvY2FuL2Rldi5jCisrKyBiL2RyaXZlcnMvbmV0L2Nhbi9kZXYuYwpAQCAtODA3LDEwICs4MDcsMTQgQEAKIAkJaWYgKGRldi0+ZmxhZ3MgJiBJRkZfVVApCiAJCQlyZXR1cm4gLUVCVVNZOwogCQljbSA9IG5sYV9kYXRhKGRhdGFbSUZMQV9DQU5fQ1RSTE1PREVdKTsKLQkJaWYgKGNtLT5mbGFncyAmIH5wcml2LT5jdHJsbW9kZV9zdXBwb3J0ZWQpCisKKwkJLyogY2hlY2sgd2hldGhlciBjaGFuZ2VkIGJpdHMgYXJlIGFsbG93ZWQgdG8gYmUgbW9kaWZpZWQgKi8KKwkJaWYgKGNtLT5tYXNrICYgfnByaXYtPmN0cmxtb2RlX3N1cHBvcnRlZCkKIAkJCXJldHVybiAtRU9QTk9UU1VQUDsKKworCQkvKiBjbGVhciBiaXRzIHRvIGJlIG1vZGlmaWVkIGFuZCBjb3B5IHRoZSBmbGFnIHZhbHVlcyAqLwogCQlwcml2LT5jdHJsbW9kZSAmPSB+Y20tPm1hc2s7Ci0JCXByaXYtPmN0cmxtb2RlIHw9IGNtLT5mbGFnczsKKwkJcHJpdi0+Y3RybG1vZGUgfD0gKGNtLT5mbGFncyAmIGNtLT5tYXNrKTsKIAogCQkvKiBDQU5fQ1RSTE1PREVfRkQgY2FuIG9ubHkgYmUgc2V0IHdoZW4gZHJpdmVyIHN1cHBvcnRzIEZEICovCiAJCWlmIChwcml2LT5jdHJsbW9kZSAmIENBTl9DVFJMTU9ERV9GRCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2Nhbi9tX2Nhbi9tX2Nhbi5jIGIvZHJpdmVycy9uZXQvY2FuL21fY2FuL21fY2FuLmMKaW5kZXggZDdiYzQ2Mi4uMjQ0NTI5OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvY2FuL21fY2FuL21fY2FuLmMKKysrIGIvZHJpdmVycy9uZXQvY2FuL21fY2FuL21fY2FuLmMKQEAgLTk1NSw2ICs5NTUsMTEgQEAKIAlwcml2LT5jYW4uZGF0YV9iaXR0aW1pbmdfY29uc3QgPSAmbV9jYW5fZGF0YV9iaXR0aW1pbmdfY29uc3Q7CiAJcHJpdi0+Y2FuLmRvX3NldF9tb2RlID0gbV9jYW5fc2V0X21vZGU7CiAJcHJpdi0+Y2FuLmRvX2dldF9iZXJyX2NvdW50ZXIgPSBtX2Nhbl9nZXRfYmVycl9jb3VudGVyOworCisJLyogQ0FOX0NUUkxNT0RFX0ZEX05PTl9JU08gaXMgZml4ZWQgd2l0aCBNX0NBTiBJUCB2My4wLjEgKi8KKwlwcml2LT5jYW4uY3RybG1vZGUgPSBDQU5fQ1RSTE1PREVfRkRfTk9OX0lTTzsKKworCS8qIENBTl9DVFJMTU9ERV9GRF9OT05fSVNPIGNhbiBub3QgYmUgY2hhbmdlZCB3aXRoIE1fQ0FOIElQIHYzLjAuMSAqLwogCXByaXYtPmNhbi5jdHJsbW9kZV9zdXBwb3J0ZWQgPSBDQU5fQ1RSTE1PREVfTE9PUEJBQ0sgfAogCQkJCQlDQU5fQ1RSTE1PREVfTElTVEVOT05MWSB8CiAJCQkJCUNBTl9DVFJMTU9ERV9CRVJSX1JFUE9SVElORyB8CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9jYW4vdXNiL2t2YXNlcl91c2IuYyBiL2RyaXZlcnMvbmV0L2Nhbi91c2Iva3Zhc2VyX3VzYi5jCmluZGV4IDU0MWZiN2EuLjdhZjM3OWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2Nhbi91c2Iva3Zhc2VyX3VzYi5jCisrKyBiL2RyaXZlcnMvbmV0L2Nhbi91c2Iva3Zhc2VyX3VzYi5jCkBAIC01MjAsMTAgKzUyMCwxMCBAQAogCQlza2IgPSBhbGxvY19jYW5fZXJyX3NrYihwcml2LT5uZXRkZXYsICZjZik7CiAJCWlmIChza2IpIHsKIAkJCWNmLT5jYW5faWQgfD0gQ0FOX0VSUl9SRVNUQVJURUQ7Ci0JCQluZXRpZl9yeChza2IpOwogCiAJCQlzdGF0cy0+cnhfcGFja2V0cysrOwogCQkJc3RhdHMtPnJ4X2J5dGVzICs9IGNmLT5jYW5fZGxjOworCQkJbmV0aWZfcngoc2tiKTsKIAkJfSBlbHNlIHsKIAkJCW5ldGRldl9lcnIocHJpdi0+bmV0ZGV2LAogCQkJCSAgICJObyBtZW1vcnkgbGVmdCBmb3IgZXJyX3NrYlxuIik7CkBAIC01ODcsNyArNTg3LDcgQEAKIAkJCSAgdXNiX3NuZGJ1bGtwaXBlKGRldi0+dWRldiwKIAkJCQkJICBkZXYtPmJ1bGtfb3V0LT5iRW5kcG9pbnRBZGRyZXNzKSwKIAkJCSAgYnVmLCBtc2ctPmxlbiwKLQkJCSAga3Zhc2VyX3VzYl9zaW1wbGVfbXNnX2NhbGxiYWNrLCBwcml2KTsKKwkJCSAga3Zhc2VyX3VzYl9zaW1wbGVfbXNnX2NhbGxiYWNrLCBuZXRkZXYpOwogCXVzYl9hbmNob3JfdXJiKHVyYiwgJnByaXYtPnR4X3N1Ym1pdHRlZCk7CiAKIAllcnIgPSB1c2Jfc3VibWl0X3VyYih1cmIsIEdGUF9BVE9NSUMpOwpAQCAtNjYyLDExICs2NjIsNiBAQAogCXByaXYgPSBkZXYtPm5ldHNbY2hhbm5lbF07CiAJc3RhdHMgPSAmcHJpdi0+bmV0ZGV2LT5zdGF0czsKIAotCWlmIChzdGF0dXMgJiBNMTZDX1NUQVRFX0JVU19SRVNFVCkgewotCQlrdmFzZXJfdXNiX3VubGlua190eF91cmJzKHByaXYpOwotCQlyZXR1cm47Ci0JfQotCiAJc2tiID0gYWxsb2NfY2FuX2Vycl9za2IocHJpdi0+bmV0ZGV2LCAmY2YpOwogCWlmICghc2tiKSB7CiAJCXN0YXRzLT5yeF9kcm9wcGVkKys7CkBAIC02NzcsNyArNjcyLDcgQEAKIAogCW5ldGRldl9kYmcocHJpdi0+bmV0ZGV2LCAiRXJyb3Igc3RhdHVzOiAweCUwMnhcbiIsIHN0YXR1cyk7CiAKLQlpZiAoc3RhdHVzICYgTTE2Q19TVEFURV9CVVNfT0ZGKSB7CisJaWYgKHN0YXR1cyAmIChNMTZDX1NUQVRFX0JVU19PRkYgfCBNMTZDX1NUQVRFX0JVU19SRVNFVCkpIHsKIAkJY2YtPmNhbl9pZCB8PSBDQU5fRVJSX0JVU09GRjsKIAogCQlwcml2LT5jYW4uY2FuX3N0YXRzLmJ1c19vZmYrKzsKQEAgLTcwMyw5ICs2OTgsNyBAQAogCQl9CiAKIAkJbmV3X3N0YXRlID0gQ0FOX1NUQVRFX0VSUk9SX1BBU1NJVkU7Ci0JfQotCi0JaWYgKHN0YXR1cyA9PSBNMTZDX1NUQVRFX0JVU19FUlJPUikgeworCX0gZWxzZSBpZiAoc3RhdHVzICYgTTE2Q19TVEFURV9CVVNfRVJST1IpIHsKIAkJaWYgKChwcml2LT5jYW4uc3RhdGUgPCBDQU5fU1RBVEVfRVJST1JfV0FSTklORykgJiYKIAkJICAgICgodHhlcnIgPj0gOTYpIHx8IChyeGVyciA+PSA5NikpKSB7CiAJCQljZi0+Y2FuX2lkIHw9IENBTl9FUlJfQ1JUTDsKQEAgLTcxNSw3ICs3MDgsOCBAQAogCiAJCQlwcml2LT5jYW4uY2FuX3N0YXRzLmVycm9yX3dhcm5pbmcrKzsKIAkJCW5ld19zdGF0ZSA9IENBTl9TVEFURV9FUlJPUl9XQVJOSU5HOwotCQl9IGVsc2UgaWYgKHByaXYtPmNhbi5zdGF0ZSA+IENBTl9TVEFURV9FUlJPUl9BQ1RJVkUpIHsKKwkJfSBlbHNlIGlmICgocHJpdi0+Y2FuLnN0YXRlID4gQ0FOX1NUQVRFX0VSUk9SX0FDVElWRSkgJiYKKwkJCSAgICgodHhlcnIgPCA5NikgJiYgKHJ4ZXJyIDwgOTYpKSkgewogCQkJY2YtPmNhbl9pZCB8PSBDQU5fRVJSX1BST1Q7CiAJCQljZi0+ZGF0YVsyXSA9IENBTl9FUlJfUFJPVF9BQ1RJVkU7CiAKQEAgLTc3MCwxMCArNzY0LDkgQEAKIAogCXByaXYtPmNhbi5zdGF0ZSA9IG5ld19zdGF0ZTsKIAotCW5ldGlmX3J4KHNrYik7Ci0KIAlzdGF0cy0+cnhfcGFja2V0cysrOwogCXN0YXRzLT5yeF9ieXRlcyArPSBjZi0+Y2FuX2RsYzsKKwluZXRpZl9yeChza2IpOwogfQogCiBzdGF0aWMgdm9pZCBrdmFzZXJfdXNiX3J4X2Nhbl9lcnIoY29uc3Qgc3RydWN0IGt2YXNlcl91c2JfbmV0X3ByaXYgKnByaXYsCkBAIC04MDUsMTAgKzc5OCw5IEBACiAJCXN0YXRzLT5yeF9vdmVyX2Vycm9ycysrOwogCQlzdGF0cy0+cnhfZXJyb3JzKys7CiAKLQkJbmV0aWZfcngoc2tiKTsKLQogCQlzdGF0cy0+cnhfcGFja2V0cysrOwogCQlzdGF0cy0+cnhfYnl0ZXMgKz0gY2YtPmNhbl9kbGM7CisJCW5ldGlmX3J4KHNrYik7CiAJfQogfQogCkBAIC04ODcsMTAgKzg3OSw5IEBACiAJCQkgICAgICAgY2YtPmNhbl9kbGMpOwogCX0KIAotCW5ldGlmX3J4KHNrYik7Ci0KIAlzdGF0cy0+cnhfcGFja2V0cysrOwogCXN0YXRzLT5yeF9ieXRlcyArPSBjZi0+Y2FuX2RsYzsKKwluZXRpZl9yeChza2IpOwogfQogCiBzdGF0aWMgdm9pZCBrdmFzZXJfdXNiX3N0YXJ0X2NoaXBfcmVwbHkoY29uc3Qgc3RydWN0IGt2YXNlcl91c2IgKmRldiwKQEAgLTEyNDYsNiArMTIzNyw5IEBACiAJaWYgKGVycikKIAkJbmV0ZGV2X3dhcm4obmV0ZGV2LCAiQ2Fubm90IHN0b3AgZGV2aWNlLCBlcnJvciAlZFxuIiwgZXJyKTsKIAorCS8qIHJlc2V0IHR4IGNvbnRleHRzICovCisJa3Zhc2VyX3VzYl91bmxpbmtfdHhfdXJicyhwcml2KTsKKwogCXByaXYtPmNhbi5zdGF0ZSA9IENBTl9TVEFURV9TVE9QUEVEOwogCWNsb3NlX2NhbmRldihwcml2LT5uZXRkZXYpOwogCkBAIC0xMjk0LDEyICsxMjg4LDE0IEBACiAJaWYgKCF1cmIpIHsKIAkJbmV0ZGV2X2VycihuZXRkZXYsICJObyBtZW1vcnkgbGVmdCBmb3IgVVJCc1xuIik7CiAJCXN0YXRzLT50eF9kcm9wcGVkKys7Ci0JCWdvdG8gbm91cmJtZW07CisJCWRldl9rZnJlZV9za2Ioc2tiKTsKKwkJcmV0dXJuIE5FVERFVl9UWF9PSzsKIAl9CiAKIAlidWYgPSBrbWFsbG9jKHNpemVvZihzdHJ1Y3Qga3Zhc2VyX21zZyksIEdGUF9BVE9NSUMpOwogCWlmICghYnVmKSB7CiAJCXN0YXRzLT50eF9kcm9wcGVkKys7CisJCWRldl9rZnJlZV9za2Ioc2tiKTsKIAkJZ290byBub2J1Zm1lbTsKIAl9CiAKQEAgLTEzMzQsNiArMTMzMCw3IEBACiAJCX0KIAl9CiAKKwkvKiBUaGlzIHNob3VsZCBuZXZlciBoYXBwZW47IGl0IGltcGxpZXMgYSBmbG93IGNvbnRyb2wgYnVnICovCiAJaWYgKCFjb250ZXh0KSB7CiAJCW5ldGRldl93YXJuKG5ldGRldiwgImNhbm5vdCBmaW5kIGZyZWUgY29udGV4dFxuIik7CiAJCXJldCA9ICBORVRERVZfVFhfQlVTWTsKQEAgLTEzNjQsOSArMTM2MSw2IEBACiAJaWYgKHVubGlrZWx5KGVycikpIHsKIAkJY2FuX2ZyZWVfZWNob19za2IobmV0ZGV2LCBjb250ZXh0LT5lY2hvX2luZGV4KTsKIAotCQlza2IgPSBOVUxMOyAvKiBzZXQgdG8gTlVMTCB0byBhdm9pZCBkb3VibGUgZnJlZSBpbgotCQkJICAgICAqIGRldl9rZnJlZV9za2Ioc2tiKSAqLwotCiAJCWF0b21pY19kZWMoJnByaXYtPmFjdGl2ZV90eF91cmJzKTsKIAkJdXNiX3VuYW5jaG9yX3VyYih1cmIpOwogCkBAIC0xMzg4LDggKzEzODIsNiBAQAogCWtmcmVlKGJ1Zik7CiBub2J1Zm1lbToKIAl1c2JfZnJlZV91cmIodXJiKTsKLW5vdXJibWVtOgotCWRldl9rZnJlZV9za2Ioc2tiKTsKIAlyZXR1cm4gcmV0OwogfQogCkBAIC0xNTAyLDYgKzE0OTQsMTAgQEAKIAlzdHJ1Y3Qga3Zhc2VyX3VzYl9uZXRfcHJpdiAqcHJpdjsKIAlpbnQgaSwgZXJyOwogCisJZXJyID0ga3Zhc2VyX3VzYl9zZW5kX3NpbXBsZV9tc2coZGV2LCBDTURfUkVTRVRfQ0hJUCwgY2hhbm5lbCk7CisJaWYgKGVycikKKwkJcmV0dXJuIGVycjsKKwogCW5ldGRldiA9IGFsbG9jX2NhbmRldihzaXplb2YoKnByaXYpLCBNQVhfVFhfVVJCUyk7CiAJaWYgKCFuZXRkZXYpIHsKIAkJZGV2X2VycigmaW50Zi0+ZGV2LCAiQ2Fubm90IGFsbG9jIGNhbmRldlxuIik7CkBAIC0xNTg4LDcgKzE1ODQsNyBAQAogewogCXN0cnVjdCBrdmFzZXJfdXNiICpkZXY7CiAJaW50IGVyciA9IC1FTk9NRU07Ci0JaW50IGk7CisJaW50IGksIHJldHJ5ID0gMzsKIAogCWRldiA9IGRldm1fa3phbGxvYygmaW50Zi0+ZGV2LCBzaXplb2YoKmRldiksIEdGUF9LRVJORUwpOwogCWlmICghZGV2KQpAQCAtMTYwNiwxMCArMTYwMiwxNSBAQAogCiAJdXNiX3NldF9pbnRmZGF0YShpbnRmLCBkZXYpOwogCi0JZm9yIChpID0gMDsgaSA8IE1BWF9ORVRfREVWSUNFUzsgaSsrKQotCQlrdmFzZXJfdXNiX3NlbmRfc2ltcGxlX21zZyhkZXYsIENNRF9SRVNFVF9DSElQLCBpKTsKKwkvKiBPbiBzb21lIHg4NiBsYXB0b3BzLCBwbHVnZ2luZyBhIEt2YXNlciBkZXZpY2UgYWdhaW4gYWZ0ZXIKKwkgKiBhbiB1bnBsdWcgbWFrZXMgdGhlIGZpcm13YXJlIGFsd2F5cyBpZ25vcmUgdGhlIHZlcnkgZmlyc3QKKwkgKiBjb21tYW5kLiBGb3Igc3VjaCBhIGNhc2UsIHByb3ZpZGUgc29tZSByb29tIGZvciByZXRyaWVzCisJICogaW5zdGVhZCBvZiBjb21wbGV0ZWx5IGV4aXRpbmcgdGhlIGRyaXZlci4KKwkgKi8KKwlkbyB7CisJCWVyciA9IGt2YXNlcl91c2JfZ2V0X3NvZnR3YXJlX2luZm8oZGV2KTsKKwl9IHdoaWxlICgtLXJldHJ5ICYmIGVyciA9PSAtRVRJTUVET1VUKTsKIAotCWVyciA9IGt2YXNlcl91c2JfZ2V0X3NvZnR3YXJlX2luZm8oZGV2KTsKIAlpZiAoZXJyKSB7CiAJCWRldl9lcnIoJmludGYtPmRldiwKIAkJCSJDYW5ub3QgZ2V0IHNvZnR3YXJlIGluZm9zLCBlcnJvciAlZFxuIiwgZXJyKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L2FtZC9LY29uZmlnIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvYW1kL0tjb25maWcKaW5kZXggN2E1ZTRhYS4uNzdmMWY2MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvYW1kL0tjb25maWcKKysrIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvYW1kL0tjb25maWcKQEAgLTQ1LDcgKzQ1LDcgQEAKIAogY29uZmlnIExBTkNFCiAJdHJpc3RhdGUgIkFNRCBMQU5DRSBhbmQgUENuZXQgKEFUMTUwMCBhbmQgTkUyMTAwKSBzdXBwb3J0IgotCWRlcGVuZHMgb24gSVNBICYmIElTQV9ETUFfQVBJCisJZGVwZW5kcyBvbiBJU0EgJiYgSVNBX0RNQV9BUEkgJiYgIUFSTQogCS0tLWhlbHAtLS0KIAkgIElmIHlvdSBoYXZlIGEgbmV0d29yayAoRXRoZXJuZXQpIGNhcmQgb2YgdGhpcyB0eXBlLCBzYXkgWSBhbmQgcmVhZAogCSAgdGhlIEV0aGVybmV0LUhPV1RPLCBhdmFpbGFibGUgZnJvbQpAQCAtMTQyLDcgKzE0Miw3IEBACiAKIGNvbmZpZyBOSTY1CiAJdHJpc3RhdGUgIk5JNjUxMCBzdXBwb3J0IgotCWRlcGVuZHMgb24gSVNBICYmIElTQV9ETUFfQVBJCisJZGVwZW5kcyBvbiBJU0EgJiYgSVNBX0RNQV9BUEkgJiYgIUFSTQogCS0tLWhlbHAtLS0KIAkgIElmIHlvdSBoYXZlIGEgbmV0d29yayAoRXRoZXJuZXQpIGNhcmQgb2YgdGhpcyB0eXBlLCBzYXkgWSBhbmQgcmVhZAogCSAgdGhlIEV0aGVybmV0LUhPV1RPLCBhdmFpbGFibGUgZnJvbQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvYW1kL25tY2xhbl9jcy5jIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvYW1kL25tY2xhbl9jcy5jCmluZGV4IDViMjI3NjQuLjI3MjQ1ZWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L2FtZC9ubWNsYW5fY3MuYworKysgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9hbWQvbm1jbGFuX2NzLmMKQEAgLTk1Miw2ICs5NTIsOCBAQAogICBkbyB7CiAgICAgLyogV0FSTklORzogTUFDRV9JUiBpcyBhIFJFQUQvQ0xFQVIgcG9ydCEgKi8KICAgICBzdGF0dXMgPSBpbmIoaW9hZGRyICsgQU0yMTUwX01BQ0VfQkFTRSArIE1BQ0VfSVIpOworICAgIGlmICghKHN0YXR1cyAmIH5NQUNFX0lNUl9ERUZBVUxUKSAmJiBJbnRyQ250ID09IE1BQ0VfTUFYX0lSX0lURVJBVElPTlMpCisgICAgICByZXR1cm4gSVJRX05PTkU7CiAKICAgICBwcl9kZWJ1ZygibWFjZV9pbnRlcnJ1cHQ6IGlycSAweCVYIHN0YXR1cyAweCVYLlxuIiwgaXJxLCBzdGF0dXMpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9hbWQveGdiZS94Z2JlLWNvbW1vbi5oIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvYW1kL3hnYmUveGdiZS1jb21tb24uaAppbmRleCA3NWIwOGM2Li4yOWEwOTI3IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9hbWQveGdiZS94Z2JlLWNvbW1vbi5oCisrKyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L2FtZC94Z2JlL3hnYmUtY29tbW9uLmgKQEAgLTc2NywxNiArNzY3LDE3IEBACiAjZGVmaW5lIE1UTF9RX1JRT01SCQkJMHg0MAogI2RlZmluZSBNVExfUV9SUU1QT0NSCQkJMHg0NAogI2RlZmluZSBNVExfUV9SUURSCQkJMHg0YworI2RlZmluZSBNVExfUV9SUUZDUgkJCTB4NTAKICNkZWZpbmUgTVRMX1FfSUVSCQkJMHg3MAogI2RlZmluZSBNVExfUV9JU1IJCQkweDc0CiAKIC8qIE1UTCBxdWV1ZSByZWdpc3RlciBlbnRyeSBiaXQgcG9zaXRpb25zIGFuZCBzaXplcyAqLworI2RlZmluZSBNVExfUV9SUUZDUl9SRkFfSU5ERVgJCTEKKyNkZWZpbmUgTVRMX1FfUlFGQ1JfUkZBX1dJRFRICQk2CisjZGVmaW5lIE1UTF9RX1JRRkNSX1JGRF9JTkRFWAkJMTcKKyNkZWZpbmUgTVRMX1FfUlFGQ1JfUkZEX1dJRFRICQk2CiAjZGVmaW5lIE1UTF9RX1JRT01SX0VIRkNfSU5ERVgJCTcKICNkZWZpbmUgTVRMX1FfUlFPTVJfRUhGQ19XSURUSAkJMQotI2RlZmluZSBNVExfUV9SUU9NUl9SRkFfSU5ERVgJCTgKLSNkZWZpbmUgTVRMX1FfUlFPTVJfUkZBX1dJRFRICQkzCi0jZGVmaW5lIE1UTF9RX1JRT01SX1JGRF9JTkRFWAkJMTMKLSNkZWZpbmUgTVRMX1FfUlFPTVJfUkZEX1dJRFRICQkzCiAjZGVmaW5lIE1UTF9RX1JRT01SX1JRU19JTkRFWAkJMTYKICNkZWZpbmUgTVRMX1FfUlFPTVJfUlFTX1dJRFRICQk5CiAjZGVmaW5lIE1UTF9RX1JRT01SX1JTRl9JTkRFWAkJNQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvYW1kL3hnYmUveGdiZS1kZXYuYyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L2FtZC94Z2JlL3hnYmUtZGV2LmMKaW5kZXggNTNmNWY2Ni4uNGM2NmNkMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvYW1kL3hnYmUveGdiZS1kZXYuYworKysgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9hbWQveGdiZS94Z2JlLWRldi5jCkBAIC0yMDc5LDEwICsyMDc5LDEwIEBACiAKIAlmb3IgKGkgPSAwOyBpIDwgcGRhdGEtPnJ4X3FfY291bnQ7IGkrKykgewogCQkvKiBBY3RpdmF0ZSBmbG93IGNvbnRyb2wgd2hlbiBsZXNzIHRoYW4gNGsgbGVmdCBpbiBmaWZvICovCi0JCVhHTUFDX01UTF9JT1dSSVRFX0JJVFMocGRhdGEsIGksIE1UTF9RX1JRT01SLCBSRkEsIDIpOworCQlYR01BQ19NVExfSU9XUklURV9CSVRTKHBkYXRhLCBpLCBNVExfUV9SUUZDUiwgUkZBLCAyKTsKIAogCQkvKiBEZS1hY3RpdmF0ZSBmbG93IGNvbnRyb2wgd2hlbiBtb3JlIHRoYW4gNmsgbGVmdCBpbiBmaWZvICovCi0JCVhHTUFDX01UTF9JT1dSSVRFX0JJVFMocGRhdGEsIGksIE1UTF9RX1JRT01SLCBSRkQsIDQpOworCQlYR01BQ19NVExfSU9XUklURV9CSVRTKHBkYXRhLCBpLCBNVExfUV9SUUZDUiwgUkZELCA0KTsKIAl9CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L2FtZC94Z2JlL3hnYmUtZHJ2LmMgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9hbWQveGdiZS94Z2JlLWRydi5jCmluZGV4IDdiYjVmMDcuLmU1ZmZiMmMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L2FtZC94Z2JlL3hnYmUtZHJ2LmMKKysrIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvYW1kL3hnYmUveGdiZS1kcnYuYwpAQCAtNTIzLDYgKzUyMyw3IEBACiAJaHdfZmVhdC0+c3BoICAgICAgICAgICA9IFhHTUFDX0dFVF9CSVRTKG1hY19oZnIxLCBNQUNfSFdGMVIsIFNQSEVOKTsKIAlod19mZWF0LT50c28gICAgICAgICAgID0gWEdNQUNfR0VUX0JJVFMobWFjX2hmcjEsIE1BQ19IV0YxUiwgVFNPRU4pOwogCWh3X2ZlYXQtPmRtYV9kZWJ1ZyAgICAgPSBYR01BQ19HRVRfQklUUyhtYWNfaGZyMSwgTUFDX0hXRjFSLCBEQkdNRU1BKTsKKwlod19mZWF0LT5yc3MgICAgICAgICAgID0gWEdNQUNfR0VUX0JJVFMobWFjX2hmcjEsIE1BQ19IV0YxUiwgUlNTRU4pOwogCWh3X2ZlYXQtPnRjX2NudAkgICAgICAgPSBYR01BQ19HRVRfQklUUyhtYWNfaGZyMSwgTUFDX0hXRjFSLCBOVU1UQyk7CiAJaHdfZmVhdC0+aGFzaF90YWJsZV9zaXplID0gWEdNQUNfR0VUX0JJVFMobWFjX2hmcjEsIE1BQ19IV0YxUiwKIAkJCQkJCSAgSEFTSFRCTFNaKTsKQEAgLTU1MiwxMyArNTUzLDE0IEBACiAJCWJyZWFrOwogCX0KIAotCS8qIFRoZSBRdWV1ZSBhbmQgQ2hhbm5lbCBjb3VudHMgYXJlIHplcm8gYmFzZWQgc28gaW5jcmVtZW50IHRoZW0KKwkvKiBUaGUgUXVldWUsIENoYW5uZWwgYW5kIFRDIGNvdW50cyBhcmUgemVybyBiYXNlZCBzbyBpbmNyZW1lbnQgdGhlbQogCSAqIHRvIGdldCB0aGUgYWN0dWFsIG51bWJlcgogCSAqLwogCWh3X2ZlYXQtPnJ4X3FfY250Kys7CiAJaHdfZmVhdC0+dHhfcV9jbnQrKzsKIAlod19mZWF0LT5yeF9jaF9jbnQrKzsKIAlod19mZWF0LT50eF9jaF9jbnQrKzsKKwlod19mZWF0LT50Y19jbnQrKzsKIAogCURCR1BSKCI8LS14Z2JlX2dldF9hbGxfaHdfZmVhdHVyZXNcbiIpOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvYXBtL3hnZW5lL3hnZW5lX2VuZXRfbWFpbi5jIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvYXBtL3hnZW5lL3hnZW5lX2VuZXRfbWFpbi5jCmluZGV4IDgzYTUwMjguLjc5M2YzYjcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L2FwbS94Z2VuZS94Z2VuZV9lbmV0X21haW4uYworKysgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9hcG0veGdlbmUveGdlbmVfZW5ldF9tYWluLmMKQEAgLTM2OSw2ICszNjksOCBAQAogCQlpZiAodW5saWtlbHkoeGdlbmVfZW5ldF9pc19kZXNjX3Nsb3RfZW1wdHkocmF3X2Rlc2MpKSkKIAkJCWJyZWFrOwogCisJCS8qIHJlYWQgZnBxbnVtIGZpZWxkIGFmdGVyIGRhdGFhZGRyIGZpZWxkICovCisJCWRtYV9ybWIoKTsKIAkJaWYgKGlzX3J4X2Rlc2MocmF3X2Rlc2MpKQogCQkJcmV0ID0geGdlbmVfZW5ldF9yeF9mcmFtZShyaW5nLCByYXdfZGVzYyk7CiAJCWVsc2UKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L2Jyb2FkY29tL2JnbWFjLmMgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9icm9hZGNvbS9iZ21hYy5jCmluZGV4IDA1YzZhZjYuLjMwMDdkOTUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L2Jyb2FkY29tL2JnbWFjLmMKKysrIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvYnJvYWRjb20vYmdtYWMuYwpAQCAtMTE2NywxMCArMTE2NywxMCBAQAogCQliZ21hYy0+aW50X3N0YXR1cyA9IDA7CiAJfQogCi0JaWYgKGhhbmRsZWQgPCB3ZWlnaHQpCisJaWYgKGhhbmRsZWQgPCB3ZWlnaHQpIHsKIAkJbmFwaV9jb21wbGV0ZShuYXBpKTsKLQotCWJnbWFjX2NoaXBfaW50cnNfb24oYmdtYWMpOworCQliZ21hY19jaGlwX2ludHJzX29uKGJnbWFjKTsKKwl9CiAKIAlyZXR1cm4gaGFuZGxlZDsKIH0KQEAgLTE1MTUsNiArMTUxNSw4IEBACiAJaWYgKGNvcmUtPmJ1cy0+c3Byb20uYm9hcmRmbGFnc19sbyAmIEJHTUFDX0JGTF9FTkVUQURNKQogCQliZ21hY193YXJuKGJnbWFjLCAiU3VwcG9ydCBmb3IgQURNdGVrIGV0aGVybmV0IHN3aXRjaCBub3QgaW1wbGVtZW50ZWRcbiIpOwogCisJbmV0aWZfbmFwaV9hZGQobmV0X2RldiwgJmJnbWFjLT5uYXBpLCBiZ21hY19wb2xsLCBCR01BQ19XRUlHSFQpOworCiAJZXJyID0gYmdtYWNfbWlpX3JlZ2lzdGVyKGJnbWFjKTsKIAlpZiAoZXJyKSB7CiAJCWJnbWFjX2VycihiZ21hYywgIkNhbm5vdCByZWdpc3RlciBNRElPXG4iKTsKQEAgLTE1MjksOCArMTUzMSw2IEBACiAKIAluZXRpZl9jYXJyaWVyX29mZihuZXRfZGV2KTsKIAotCW5ldGlmX25hcGlfYWRkKG5ldF9kZXYsICZiZ21hYy0+bmFwaSwgYmdtYWNfcG9sbCwgQkdNQUNfV0VJR0hUKTsKLQogCXJldHVybiAwOwogCiBlcnJfbWlpX3VucmVnaXN0ZXI6CkBAIC0xNTQ5LDkgKzE1NDksOSBAQAogewogCXN0cnVjdCBiZ21hYyAqYmdtYWMgPSBiY21hX2dldF9kcnZkYXRhKGNvcmUpOwogCi0JbmV0aWZfbmFwaV9kZWwoJmJnbWFjLT5uYXBpKTsKIAl1bnJlZ2lzdGVyX25ldGRldihiZ21hYy0+bmV0X2Rldik7CiAJYmdtYWNfbWlpX3VucmVnaXN0ZXIoYmdtYWMpOworCW5ldGlmX25hcGlfZGVsKCZiZ21hYy0+bmFwaSk7CiAJYmdtYWNfZG1hX2ZyZWUoYmdtYWMpOwogCWJjbWFfc2V0X2RydmRhdGEoY29yZSwgTlVMTCk7CiAJZnJlZV9uZXRkZXYoYmdtYWMtPm5ldF9kZXYpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvYnJvYWRjb20vYm54MngvYm54MnhfY21uLmMgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9icm9hZGNvbS9ibngyeC9ibngyeF9jbW4uYwppbmRleCAxZDExNDdjLi5lNDY4ZWQzIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9icm9hZGNvbS9ibngyeC9ibngyeF9jbW4uYworKysgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9icm9hZGNvbS9ibngyeC9ibngyeF9jbW4uYwpAQCAtMzE3NSw3ICszMTc1LDcgQEAKIAkJfQogI2VuZGlmCiAJCWlmICghYm54MnhfZnBfbG9ja19uYXBpKGZwKSkKLQkJCXJldHVybiB3b3JrX2RvbmU7CisJCQlyZXR1cm4gYnVkZ2V0OwogCiAJCWZvcl9lYWNoX2Nvc19pbl90eF9xdWV1ZShmcCwgY29zKQogCQkJaWYgKGJueDJ4X3R4X3F1ZXVlX2hhc193b3JrKGZwLT50eGRhdGFfcHRyW2Nvc10pKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvY2lycnVzL0tjb25maWcgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9jaXJydXMvS2NvbmZpZwppbmRleCA3NDAzZGZmLi45MDVhYzVmIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9jaXJydXMvS2NvbmZpZworKysgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9jaXJydXMvS2NvbmZpZwpAQCAtMzIsNyArMzIsOCBAQAogCSAgd2lsbCBiZSBjYWxsZWQgY3M4OXgwLgogCiBjb25maWcgQ1M4OXgwX1BMQVRGT1JNCi0JYm9vbCAiQ1M4OXgwIHBsYXRmb3JtIGRyaXZlciBzdXBwb3J0IgorCWJvb2wgIkNTODl4MCBwbGF0Zm9ybSBkcml2ZXIgc3VwcG9ydCIgaWYgSEFTX0lPUE9SVF9NQVAKKwlkZWZhdWx0ICFIQVNfSU9QT1JUX01BUAogCWRlcGVuZHMgb24gQ1M4OXgwCiAJaGVscAogCSAgU2F5IFkgdG8gY29tcGlsZSB0aGUgY3M4OXgwIGRyaXZlciBhcyBhIHBsYXRmb3JtIGRyaXZlci4gVGhpcwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvY2lzY28vZW5pYy9lbmljX21haW4uYyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L2Npc2NvL2VuaWMvZW5pY19tYWluLmMKaW5kZXggYjI5ZTAyNy4uZTM1NmFmYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvY2lzY28vZW5pYy9lbmljX21haW4uYworKysgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9jaXNjby9lbmljL2VuaWNfbWFpbi5jCkBAIC0xMzM1LDcgKzEzMzUsNyBAQAogCWludCBlcnI7CiAKIAlpZiAoIWVuaWNfcG9sbF9sb2NrX25hcGkoJmVuaWMtPnJxW3JxXSkpCi0JCXJldHVybiB3b3JrX2RvbmU7CisJCXJldHVybiBidWRnZXQ7CiAJLyogU2VydmljZSBSUQogCSAqLwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9lbXVsZXgvYmVuZXQvYmVfbWFpbi5jIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvZW11bGV4L2JlbmV0L2JlX21haW4uYwppbmRleCA0MWEwYTU0Li5kNDg4MDZiIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9lbXVsZXgvYmVuZXQvYmVfbWFpbi5jCisrKyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L2VtdWxleC9iZW5ldC9iZV9tYWluLmMKQEAgLTQzODMsOCArNDM4Myw5IEBACiAgKiBkaXN0aW5ndWlzaCB2YXJpb3VzIHR5cGVzIG9mIHRyYW5zcG9ydHMgKFZ4TEFOLCBHUkUsIE5WR1JFIC4uKS4gU28sIG9mZmxvYWQKICAqIGlzIGV4cGVjdGVkIHRvIHdvcmsgYWNyb3NzIGFsbCB0eXBlcyBvZiBJUCB0dW5uZWxzIG9uY2UgZXhwb3J0ZWQuIFNreWhhd2sKICAqIHN1cHBvcnRzIG9mZmxvYWRzIGZvciBlaXRoZXIgVnhMQU4gb3IgTlZHUkUsIGV4Y2x1c2l2ZWx5LiBTbyB3ZSBleHBvcnQgVnhMQU4KLSAqIG9mZmxvYWRzIGluIGh3X2VuY19mZWF0dXJlcyBvbmx5IHdoZW4gYSBWeExBTiBwb3J0IGlzIGFkZGVkLiBOb3RlIHRoaXMgb25seQotICogZW5zdXJlcyB0aGF0IG90aGVyIHR1bm5lbHMgd29yayBmaW5lIHdoaWxlIFZ4TEFOIG9mZmxvYWRzIGFyZSBub3QgZW5hYmxlZC4KKyAqIG9mZmxvYWRzIGluIGh3X2VuY19mZWF0dXJlcyBvbmx5IHdoZW4gYSBWeExBTiBwb3J0IGlzIGFkZGVkLiBJZiBvdGhlciAobm9uCisgKiBWeExBTikgdHVubmVscyBhcmUgY29uZmlndXJlZCB3aGlsZSBWeExBTiBvZmZsb2FkcyBhcmUgZW5hYmxlZCwgb2ZmbG9hZHMgZm9yCisgKiB0aG9zZSBvdGhlciB0dW5uZWxzIGFyZSB1bmV4cG9ydGVkIG9uIHRoZSBmbHkgdGhyb3VnaCBuZG9fZmVhdHVyZXNfY2hlY2soKS4KICAqCiAgKiBTa3loYXdrIHN1cHBvcnRzIFZ4TEFOIG9mZmxvYWRzIG9ubHkgZm9yIG9uZSBVRFAgZHBvcnQuIFNvLCBpZiB0aGUgc3RhY2sKICAqIGFkZHMgbW9yZSB0aGFuIG9uZSBwb3J0LCBkaXNhYmxlIG9mZmxvYWRzIGFuZCBkb24ndCByZS1lbmFibGUgdGhlbSBhZ2FpbgpAQCAtNDQ2Myw3ICs0NDY0LDQxIEBACiAJCQkJCSAgIHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsCiAJCQkJCSAgIG5ldGRldl9mZWF0dXJlc190IGZlYXR1cmVzKQogewotCXJldHVybiB2eGxhbl9mZWF0dXJlc19jaGVjayhza2IsIGZlYXR1cmVzKTsKKwlzdHJ1Y3QgYmVfYWRhcHRlciAqYWRhcHRlciA9IG5ldGRldl9wcml2KGRldik7CisJdTggbDRfaGRyID0gMDsKKworCS8qIFRoZSBjb2RlIGJlbG93IHJlc3RyaWN0cyBvZmZsb2FkIGZlYXR1cmVzIGZvciBzb21lIHR1bm5lbGVkIHBhY2tldHMuCisJICogT2ZmbG9hZCBmZWF0dXJlcyBmb3Igbm9ybWFsIChub24gdHVubmVsKSBwYWNrZXRzIGFyZSB1bmNoYW5nZWQuCisJICovCisJaWYgKCFza2ItPmVuY2Fwc3VsYXRpb24gfHwKKwkgICAgIShhZGFwdGVyLT5mbGFncyAmIEJFX0ZMQUdTX1ZYTEFOX09GRkxPQURTKSkKKwkJcmV0dXJuIGZlYXR1cmVzOworCisJLyogSXQncyBhbiBlbmNhcHN1bGF0ZWQgcGFja2V0IGFuZCBWeExBTiBvZmZsb2FkcyBhcmUgZW5hYmxlZC4gV2UKKwkgKiBzaG91bGQgZGlzYWJsZSB0dW5uZWwgb2ZmbG9hZCBmZWF0dXJlcyBpZiBpdCdzIG5vdCBhIFZ4TEFOIHBhY2tldCwKKwkgKiBhcyB0dW5uZWwgb2ZmbG9hZHMgaGF2ZSBiZWVuIGVuYWJsZWQgb25seSBmb3IgVnhMQU4uIFRoaXMgaXMgZG9uZSB0bworCSAqIGFsbG93IG90aGVyIHR1bm5lbGVkIHRyYWZmaWMgbGlrZSBHUkUgd29yayBmaW5lIHdoaWxlIFZ4TEFOCisJICogb2ZmbG9hZHMgYXJlIGNvbmZpZ3VyZWQgaW4gU2t5aGF3ay1SLgorCSAqLworCXN3aXRjaCAodmxhbl9nZXRfcHJvdG9jb2woc2tiKSkgeworCWNhc2UgaHRvbnMoRVRIX1BfSVApOgorCQlsNF9oZHIgPSBpcF9oZHIoc2tiKS0+cHJvdG9jb2w7CisJCWJyZWFrOworCWNhc2UgaHRvbnMoRVRIX1BfSVBWNik6CisJCWw0X2hkciA9IGlwdjZfaGRyKHNrYiktPm5leHRoZHI7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCXJldHVybiBmZWF0dXJlczsKKwl9CisKKwlpZiAobDRfaGRyICE9IElQUFJPVE9fVURQIHx8CisJICAgIHNrYi0+aW5uZXJfcHJvdG9jb2xfdHlwZSAhPSBFTkNBUF9UWVBFX0VUSEVSIHx8CisJICAgIHNrYi0+aW5uZXJfcHJvdG9jb2wgIT0gaHRvbnMoRVRIX1BfVEVCKSB8fAorCSAgICBza2JfaW5uZXJfbWFjX2hlYWRlcihza2IpIC0gc2tiX3RyYW5zcG9ydF9oZWFkZXIoc2tiKSAhPQorCSAgICBzaXplb2Yoc3RydWN0IHVkcGhkcikgKyBzaXplb2Yoc3RydWN0IHZ4bGFuaGRyKSkKKwkJcmV0dXJuIGZlYXR1cmVzICYgfihORVRJRl9GX0FMTF9DU1VNIHwgTkVUSUZfRl9HU09fTUFTSyk7CisKKwlyZXR1cm4gZmVhdHVyZXM7CiB9CiAjZW5kaWYKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvZnJlZXNjYWxlL2dpYW5mYXJfZXRodG9vbC5jIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvZnJlZXNjYWxlL2dpYW5mYXJfZXRodG9vbC5jCmluZGV4IDNlMWE5YzEuLmZkYTEyZmIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L2ZyZWVzY2FsZS9naWFuZmFyX2V0aHRvb2wuYworKysgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9mcmVlc2NhbGUvZ2lhbmZhcl9ldGh0b29sLmMKQEAgLTE1ODYsNyArMTU4Niw3IEBACiAJCXJldHVybiAtRUJVU1k7CiAKIAkvKiBGaWxsIHJlZ3VsYXIgZW50cmllcyAqLwotCWZvciAoOyBpIDwgTUFYX0ZJTEVSX0lEWCAtIDEgJiYgKHRhYi0+ZmVbaV0uY3RybCB8IHRhYi0+ZmVbaV0uY3RybCk7CisJZm9yICg7IGkgPCBNQVhfRklMRVJfSURYIC0gMSAmJiAodGFiLT5mZVtpXS5jdHJsIHwgdGFiLT5mZVtpXS5wcm9wKTsKIAkgICAgIGkrKykKIAkJZ2Zhcl93cml0ZV9maWxlcihwcml2LCBpLCB0YWItPmZlW2ldLmN0cmwsIHRhYi0+ZmVbaV0ucHJvcCk7CiAJLyogRmlsbCB0aGUgcmVzdCB3aXRoIGZhbGwtdHJvdWdocyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvaW50ZWwvaWdidmYvbmV0ZGV2LmMgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9pbnRlbC9pZ2J2Zi9uZXRkZXYuYwppbmRleCA2M2M4MDdjLi5lZGVhMTNiIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9pbnRlbC9pZ2J2Zi9uZXRkZXYuYworKysgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9pbnRlbC9pZ2J2Zi9uZXRkZXYuYwpAQCAtMTkwNyw3ICsxOTA3LDggQEAKIAogc3RhdGljIGludCBpZ2J2Zl90c28oc3RydWN0IGlnYnZmX2FkYXB0ZXIgKmFkYXB0ZXIsCiAgICAgICAgICAgICAgICAgICAgICBzdHJ1Y3QgaWdidmZfcmluZyAqdHhfcmluZywKLSAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCBza19idWZmICpza2IsIHUzMiB0eF9mbGFncywgdTggKmhkcl9sZW4pCisJCSAgICAgc3RydWN0IHNrX2J1ZmYgKnNrYiwgdTMyIHR4X2ZsYWdzLCB1OCAqaGRyX2xlbiwKKwkJICAgICBfX2JlMTYgcHJvdG9jb2wpCiB7CiAJc3RydWN0IGUxMDAwX2Fkdl90eF9jb250ZXh0X2Rlc2MgKmNvbnRleHRfZGVzYzsKIAlzdHJ1Y3QgaWdidmZfYnVmZmVyICpidWZmZXJfaW5mbzsKQEAgLTE5MjcsNyArMTkyOCw3IEBACiAJbDRsZW4gPSB0Y3BfaGRybGVuKHNrYik7CiAJKmhkcl9sZW4gKz0gbDRsZW47CiAKLQlpZiAoc2tiLT5wcm90b2NvbCA9PSBodG9ucyhFVEhfUF9JUCkpIHsKKwlpZiAocHJvdG9jb2wgPT0gaHRvbnMoRVRIX1BfSVApKSB7CiAJCXN0cnVjdCBpcGhkciAqaXBoID0gaXBfaGRyKHNrYik7CiAJCWlwaC0+dG90X2xlbiA9IDA7CiAJCWlwaC0+Y2hlY2sgPSAwOwpAQCAtMTk1OCw3ICsxOTU5LDcgQEAKIAkvKiBBRFYgRFRZUCBUVUNNRCBNS1JMT0MvSVNDU0lIRURMRU4gKi8KIAl0dV9jbWQgfD0gKEUxMDAwX1RYRF9DTURfREVYVCB8IEUxMDAwX0FEVlRYRF9EVFlQX0NUWFQpOwogCi0JaWYgKHNrYi0+cHJvdG9jb2wgPT0gaHRvbnMoRVRIX1BfSVApKQorCWlmIChwcm90b2NvbCA9PSBodG9ucyhFVEhfUF9JUCkpCiAJCXR1X2NtZCB8PSBFMTAwMF9BRFZUWERfVFVDTURfSVBWNDsKIAl0dV9jbWQgfD0gRTEwMDBfQURWVFhEX1RVQ01EX0w0VF9UQ1A7CiAKQEAgLTE5ODQsNyArMTk4NSw4IEBACiAKIHN0YXRpYyBpbmxpbmUgYm9vbCBpZ2J2Zl90eF9jc3VtKHN0cnVjdCBpZ2J2Zl9hZGFwdGVyICphZGFwdGVyLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3RydWN0IGlnYnZmX3JpbmcgKnR4X3JpbmcsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdHJ1Y3Qgc2tfYnVmZiAqc2tiLCB1MzIgdHhfZmxhZ3MpCisJCQkJIHN0cnVjdCBza19idWZmICpza2IsIHUzMiB0eF9mbGFncywKKwkJCQkgX19iZTE2IHByb3RvY29sKQogewogCXN0cnVjdCBlMTAwMF9hZHZfdHhfY29udGV4dF9kZXNjICpjb250ZXh0X2Rlc2M7CiAJdW5zaWduZWQgaW50IGk7CkBAIC0yMDExLDcgKzIwMTMsNyBAQAogCQl0dV9jbWQgfD0gKEUxMDAwX1RYRF9DTURfREVYVCB8IEUxMDAwX0FEVlRYRF9EVFlQX0NUWFQpOwogCiAJCWlmIChza2ItPmlwX3N1bW1lZCA9PSBDSEVDS1NVTV9QQVJUSUFMKSB7Ci0JCQlzd2l0Y2ggKHNrYi0+cHJvdG9jb2wpIHsKKwkJCXN3aXRjaCAocHJvdG9jb2wpIHsKIAkJCWNhc2UgaHRvbnMoRVRIX1BfSVApOgogCQkJCXR1X2NtZCB8PSBFMTAwMF9BRFZUWERfVFVDTURfSVBWNDsKIAkJCQlpZiAoaXBfaGRyKHNrYiktPnByb3RvY29sID09IElQUFJPVE9fVENQKQpAQCAtMjIxMSw2ICsyMjEzLDcgQEAKIAl1OCBoZHJfbGVuID0gMDsKIAlpbnQgY291bnQgPSAwOwogCWludCB0c28gPSAwOworCV9fYmUxNiBwcm90b2NvbCA9IHZsYW5fZ2V0X3Byb3RvY29sKHNrYik7CiAKIAlpZiAodGVzdF9iaXQoX19JR0JWRl9ET1dOLCAmYWRhcHRlci0+c3RhdGUpKSB7CiAJCWRldl9rZnJlZV9za2JfYW55KHNrYik7CkBAIC0yMjM5LDEzICsyMjQyLDEzIEBACiAJCXR4X2ZsYWdzIHw9ICh2bGFuX3R4X3RhZ19nZXQoc2tiKSA8PCBJR0JWRl9UWF9GTEFHU19WTEFOX1NISUZUKTsKIAl9CiAKLQlpZiAoc2tiLT5wcm90b2NvbCA9PSBodG9ucyhFVEhfUF9JUCkpCisJaWYgKHByb3RvY29sID09IGh0b25zKEVUSF9QX0lQKSkKIAkJdHhfZmxhZ3MgfD0gSUdCVkZfVFhfRkxBR1NfSVBWNDsKIAogCWZpcnN0ID0gdHhfcmluZy0+bmV4dF90b191c2U7CiAKIAl0c28gPSBza2JfaXNfZ3NvKHNrYikgPwotCQlpZ2J2Zl90c28oYWRhcHRlciwgdHhfcmluZywgc2tiLCB0eF9mbGFncywgJmhkcl9sZW4pIDogMDsKKwkJaWdidmZfdHNvKGFkYXB0ZXIsIHR4X3JpbmcsIHNrYiwgdHhfZmxhZ3MsICZoZHJfbGVuLCBwcm90b2NvbCkgOiAwOwogCWlmICh1bmxpa2VseSh0c28gPCAwKSkgewogCQlkZXZfa2ZyZWVfc2tiX2FueShza2IpOwogCQlyZXR1cm4gTkVUREVWX1RYX09LOwpAQCAtMjI1Myw3ICsyMjU2LDcgQEAKIAogCWlmICh0c28pCiAJCXR4X2ZsYWdzIHw9IElHQlZGX1RYX0ZMQUdTX1RTTzsKLQllbHNlIGlmIChpZ2J2Zl90eF9jc3VtKGFkYXB0ZXIsIHR4X3JpbmcsIHNrYiwgdHhfZmxhZ3MpICYmCisJZWxzZSBpZiAoaWdidmZfdHhfY3N1bShhZGFwdGVyLCB0eF9yaW5nLCBza2IsIHR4X2ZsYWdzLCBwcm90b2NvbCkgJiYKIAkgICAgICAgICAoc2tiLT5pcF9zdW1tZWQgPT0gQ0hFQ0tTVU1fUEFSVElBTCkpCiAJCXR4X2ZsYWdzIHw9IElHQlZGX1RYX0ZMQUdTX0NTVU07CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L2ludGVsL2l4Z2JlL2l4Z2JlX21haW4uYyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L2ludGVsL2l4Z2JlL2l4Z2JlX21haW4uYwppbmRleCAyZWQyYzdkLi42N2IwMmJkIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9pbnRlbC9peGdiZS9peGdiZV9tYWluLmMKKysrIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvaW50ZWwvaXhnYmUvaXhnYmVfbWFpbi5jCkBAIC03MjI3LDExICs3MjI3LDExIEBACiAJCWlmICghdmhkcikKIAkJCWdvdG8gb3V0X2Ryb3A7CiAKLQkJcHJvdG9jb2wgPSB2aGRyLT5oX3ZsYW5fZW5jYXBzdWxhdGVkX3Byb3RvOwogCQl0eF9mbGFncyB8PSBudG9ocyh2aGRyLT5oX3ZsYW5fVENJKSA8PAogCQkJCSAgSVhHQkVfVFhfRkxBR1NfVkxBTl9TSElGVDsKIAkJdHhfZmxhZ3MgfD0gSVhHQkVfVFhfRkxBR1NfU1dfVkxBTjsKIAl9CisJcHJvdG9jb2wgPSB2bGFuX2dldF9wcm90b2NvbChza2IpOwogCiAJaWYgKHVubGlrZWx5KHNrYl9zaGluZm8oc2tiKS0+dHhfZmxhZ3MgJiBTS0JUWF9IV19UU1RBTVApICYmCiAJICAgIGFkYXB0ZXItPnB0cF9jbG9jayAmJgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvaW50ZWwvaXhnYmV2Zi9peGdiZXZmX21haW4uYyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L2ludGVsL2l4Z2JldmYvaXhnYmV2Zl9tYWluLmMKaW5kZXggNjJhMGQ4ZS4uMzhjN2EwYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvaW50ZWwvaXhnYmV2Zi9peGdiZXZmX21haW4uYworKysgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9pbnRlbC9peGdiZXZmL2l4Z2JldmZfbWFpbi5jCkBAIC0zMDk5LDcgKzMwOTksNyBAQAogCS8qIEFEViBEVFlQIFRVQ01EIE1LUkxPQy9JU0NTSUhFRExFTiAqLwogCXR5cGVfdHVjbWQgPSBJWEdCRV9BRFZUWERfVFVDTURfTDRUX1RDUDsKIAotCWlmIChza2ItPnByb3RvY29sID09IGh0b25zKEVUSF9QX0lQKSkgeworCWlmIChmaXJzdC0+cHJvdG9jb2wgPT0gaHRvbnMoRVRIX1BfSVApKSB7CiAJCXN0cnVjdCBpcGhkciAqaXBoID0gaXBfaGRyKHNrYik7CiAJCWlwaC0+dG90X2xlbiA9IDA7CiAJCWlwaC0+Y2hlY2sgPSAwOwpAQCAtMzE1Niw3ICszMTU2LDcgQEAKIAogCWlmIChza2ItPmlwX3N1bW1lZCA9PSBDSEVDS1NVTV9QQVJUSUFMKSB7CiAJCXU4IGw0X2hkciA9IDA7Ci0JCXN3aXRjaCAoc2tiLT5wcm90b2NvbCkgeworCQlzd2l0Y2ggKGZpcnN0LT5wcm90b2NvbCkgewogCQljYXNlIGh0b25zKEVUSF9QX0lQKToKIAkJCXZsYW5fbWFjaXBfbGVucyB8PSBza2JfbmV0d29ya19oZWFkZXJfbGVuKHNrYik7CiAJCQl0eXBlX3R1Y21kIHw9IElYR0JFX0FEVlRYRF9UVUNNRF9JUFY0OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvbWFydmVsbC9tdjY0M3h4X2V0aC5jIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvbWFydmVsbC9tdjY0M3h4X2V0aC5jCmluZGV4IGE2MmZjMzguLjFjNzU4MjkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L21hcnZlbGwvbXY2NDN4eF9ldGguYworKysgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9tYXJ2ZWxsL212NjQzeHhfZXRoLmMKQEAgLTE5Miw2ICsxOTIsMTAgQEAKICNkZWZpbmUgSVNfVFNPX0hFQURFUih0eHEsIGFkZHIpIFwKIAkoKGFkZHIgPj0gdHhxLT50c29faGRyc19kbWEpICYmIFwKIAkgKGFkZHIgPCB0eHEtPnRzb19oZHJzX2RtYSArIHR4cS0+dHhfcmluZ19zaXplICogVFNPX0hFQURFUl9TSVpFKSkKKworI2RlZmluZSBERVNDX0RNQV9NQVBfU0lOR0xFIDAKKyNkZWZpbmUgREVTQ19ETUFfTUFQX1BBR0UgMQorCiAvKgogICogUlgvVFggZGVzY3JpcHRvcnMuCiAgKi8KQEAgLTM2Miw2ICszNjYsNyBAQAogCWRtYV9hZGRyX3QgdHNvX2hkcnNfZG1hOwogCiAJc3RydWN0IHR4X2Rlc2MgKnR4X2Rlc2NfYXJlYTsKKwljaGFyICp0eF9kZXNjX21hcHBpbmc7IC8qIGFycmF5IHRvIHRyYWNrIHRoZSB0eXBlIG9mIHRoZSBkbWEgbWFwcGluZyAqLwogCWRtYV9hZGRyX3QgdHhfZGVzY19kbWE7CiAJaW50IHR4X2Rlc2NfYXJlYV9zaXplOwogCkBAIC03NTAsNiArNzU1LDcgQEAKIAlpZiAodHhxLT50eF9jdXJyX2Rlc2MgPT0gdHhxLT50eF9yaW5nX3NpemUpCiAJCXR4cS0+dHhfY3Vycl9kZXNjID0gMDsKIAlkZXNjID0gJnR4cS0+dHhfZGVzY19hcmVhW3R4X2luZGV4XTsKKwl0eHEtPnR4X2Rlc2NfbWFwcGluZ1t0eF9pbmRleF0gPSBERVNDX0RNQV9NQVBfU0lOR0xFOwogCiAJZGVzYy0+bDRpX2NoayA9IDA7CiAJZGVzYy0+Ynl0ZV9jbnQgPSBsZW5ndGg7CkBAIC04NzksMTQgKzg4NSwxMyBAQAogCQlza2JfZnJhZ190ICp0aGlzX2ZyYWc7CiAJCWludCB0eF9pbmRleDsKIAkJc3RydWN0IHR4X2Rlc2MgKmRlc2M7Ci0JCXZvaWQgKmFkZHI7CiAKIAkJdGhpc19mcmFnID0gJnNrYl9zaGluZm8oc2tiKS0+ZnJhZ3NbZnJhZ107Ci0JCWFkZHIgPSBwYWdlX2FkZHJlc3ModGhpc19mcmFnLT5wYWdlLnApICsgdGhpc19mcmFnLT5wYWdlX29mZnNldDsKIAkJdHhfaW5kZXggPSB0eHEtPnR4X2N1cnJfZGVzYysrOwogCQlpZiAodHhxLT50eF9jdXJyX2Rlc2MgPT0gdHhxLT50eF9yaW5nX3NpemUpCiAJCQl0eHEtPnR4X2N1cnJfZGVzYyA9IDA7CiAJCWRlc2MgPSAmdHhxLT50eF9kZXNjX2FyZWFbdHhfaW5kZXhdOworCQl0eHEtPnR4X2Rlc2NfbWFwcGluZ1t0eF9pbmRleF0gPSBERVNDX0RNQV9NQVBfUEFHRTsKIAogCQkvKgogCQkgKiBUaGUgbGFzdCBmcmFnbWVudCB3aWxsIGdlbmVyYXRlIGFuIGludGVycnVwdApAQCAtOTAyLDggKzkwNyw5IEBACiAKIAkJZGVzYy0+bDRpX2NoayA9IDA7CiAJCWRlc2MtPmJ5dGVfY250ID0gc2tiX2ZyYWdfc2l6ZSh0aGlzX2ZyYWcpOwotCQlkZXNjLT5idWZfcHRyID0gZG1hX21hcF9zaW5nbGUobXAtPmRldi0+ZGV2LnBhcmVudCwgYWRkciwKLQkJCQkJICAgICAgIGRlc2MtPmJ5dGVfY250LCBETUFfVE9fREVWSUNFKTsKKwkJZGVzYy0+YnVmX3B0ciA9IHNrYl9mcmFnX2RtYV9tYXAobXAtPmRldi0+ZGV2LnBhcmVudCwKKwkJCQkJCSB0aGlzX2ZyYWcsIDAsIGRlc2MtPmJ5dGVfY250LAorCQkJCQkJIERNQV9UT19ERVZJQ0UpOwogCX0KIH0KIApAQCAtOTM2LDYgKzk0Miw3IEBACiAJaWYgKHR4cS0+dHhfY3Vycl9kZXNjID09IHR4cS0+dHhfcmluZ19zaXplKQogCQl0eHEtPnR4X2N1cnJfZGVzYyA9IDA7CiAJZGVzYyA9ICZ0eHEtPnR4X2Rlc2NfYXJlYVt0eF9pbmRleF07CisJdHhxLT50eF9kZXNjX21hcHBpbmdbdHhfaW5kZXhdID0gREVTQ19ETUFfTUFQX1NJTkdMRTsKIAogCWlmIChucl9mcmFncykgewogCQl0eHFfc3VibWl0X2ZyYWdfc2tiKHR4cSwgc2tiKTsKQEAgLTEwNDcsOSArMTA1NCwxMiBAQAogCQlpbnQgdHhfaW5kZXg7CiAJCXN0cnVjdCB0eF9kZXNjICpkZXNjOwogCQl1MzIgY21kX3N0czsKKwkJY2hhciBkZXNjX2RtYV9tYXA7CiAKIAkJdHhfaW5kZXggPSB0eHEtPnR4X3VzZWRfZGVzYzsKIAkJZGVzYyA9ICZ0eHEtPnR4X2Rlc2NfYXJlYVt0eF9pbmRleF07CisJCWRlc2NfZG1hX21hcCA9IHR4cS0+dHhfZGVzY19tYXBwaW5nW3R4X2luZGV4XTsKKwogCQljbWRfc3RzID0gZGVzYy0+Y21kX3N0czsKIAogCQlpZiAoY21kX3N0cyAmIEJVRkZFUl9PV05FRF9CWV9ETUEpIHsKQEAgLTEwNjUsOSArMTA3NSwxOSBAQAogCQlyZWNsYWltZWQrKzsKIAkJdHhxLT50eF9kZXNjX2NvdW50LS07CiAKLQkJaWYgKCFJU19UU09fSEVBREVSKHR4cSwgZGVzYy0+YnVmX3B0cikpCi0JCQlkbWFfdW5tYXBfc2luZ2xlKG1wLT5kZXYtPmRldi5wYXJlbnQsIGRlc2MtPmJ1Zl9wdHIsCi0JCQkJCSBkZXNjLT5ieXRlX2NudCwgRE1BX1RPX0RFVklDRSk7CisJCWlmICghSVNfVFNPX0hFQURFUih0eHEsIGRlc2MtPmJ1Zl9wdHIpKSB7CisKKwkJCWlmIChkZXNjX2RtYV9tYXAgPT0gREVTQ19ETUFfTUFQX1BBR0UpCisJCQkJZG1hX3VubWFwX3BhZ2UobXAtPmRldi0+ZGV2LnBhcmVudCwKKwkJCQkJICAgICAgIGRlc2MtPmJ1Zl9wdHIsCisJCQkJCSAgICAgICBkZXNjLT5ieXRlX2NudCwKKwkJCQkJICAgICAgIERNQV9UT19ERVZJQ0UpOworCQkJZWxzZQorCQkJCWRtYV91bm1hcF9zaW5nbGUobXAtPmRldi0+ZGV2LnBhcmVudCwKKwkJCQkJCSBkZXNjLT5idWZfcHRyLAorCQkJCQkJIGRlc2MtPmJ5dGVfY250LAorCQkJCQkJIERNQV9UT19ERVZJQ0UpOworCQl9CiAKIAkJaWYgKGNtZF9zdHMgJiBUWF9FTkFCTEVfSU5URVJSVVBUKSB7CiAJCQlzdHJ1Y3Qgc2tfYnVmZiAqc2tiID0gX19za2JfZGVxdWV1ZSgmdHhxLT50eF9za2IpOwpAQCAtMTk5Niw2ICsyMDE2LDcgQEAKIAlzdHJ1Y3QgdHhfcXVldWUgKnR4cSA9IG1wLT50eHEgKyBpbmRleDsKIAlzdHJ1Y3QgdHhfZGVzYyAqdHhfZGVzYzsKIAlpbnQgc2l6ZTsKKwlpbnQgcmV0OwogCWludCBpOwogCiAJdHhxLT5pbmRleCA9IGluZGV4OwpAQCAtMjA0OCwxOCArMjA2OSwzNCBAQAogCQkJCQluZXh0aSAqIHNpemVvZihzdHJ1Y3QgdHhfZGVzYyk7CiAJfQogCisJdHhxLT50eF9kZXNjX21hcHBpbmcgPSBrY2FsbG9jKHR4cS0+dHhfcmluZ19zaXplLCBzaXplb2YoY2hhciksCisJCQkJICAgICAgIEdGUF9LRVJORUwpOworCWlmICghdHhxLT50eF9kZXNjX21hcHBpbmcpIHsKKwkJcmV0ID0gLUVOT01FTTsKKwkJZ290byBlcnJfZnJlZV9kZXNjX2FyZWE7CisJfQorCiAJLyogQWxsb2NhdGUgRE1BIGJ1ZmZlcnMgZm9yIFRTTyBNQUMvSVAvVENQIGhlYWRlcnMgKi8KIAl0eHEtPnRzb19oZHJzID0gZG1hX2FsbG9jX2NvaGVyZW50KG1wLT5kZXYtPmRldi5wYXJlbnQsCiAJCQkJCSAgIHR4cS0+dHhfcmluZ19zaXplICogVFNPX0hFQURFUl9TSVpFLAogCQkJCQkgICAmdHhxLT50c29faGRyc19kbWEsIEdGUF9LRVJORUwpOwogCWlmICh0eHEtPnRzb19oZHJzID09IE5VTEwpIHsKLQkJZG1hX2ZyZWVfY29oZXJlbnQobXAtPmRldi0+ZGV2LnBhcmVudCwgdHhxLT50eF9kZXNjX2FyZWFfc2l6ZSwKLQkJCQkgIHR4cS0+dHhfZGVzY19hcmVhLCB0eHEtPnR4X2Rlc2NfZG1hKTsKLQkJcmV0dXJuIC1FTk9NRU07CisJCXJldCA9IC1FTk9NRU07CisJCWdvdG8gZXJyX2ZyZWVfZGVzY19tYXBwaW5nOwogCX0KIAlza2JfcXVldWVfaGVhZF9pbml0KCZ0eHEtPnR4X3NrYik7CiAKIAlyZXR1cm4gMDsKKworZXJyX2ZyZWVfZGVzY19tYXBwaW5nOgorCWtmcmVlKHR4cS0+dHhfZGVzY19tYXBwaW5nKTsKK2Vycl9mcmVlX2Rlc2NfYXJlYToKKwlpZiAoaW5kZXggPT0gMCAmJiBzaXplIDw9IG1wLT50eF9kZXNjX3NyYW1fc2l6ZSkKKwkJaW91bm1hcCh0eHEtPnR4X2Rlc2NfYXJlYSk7CisJZWxzZQorCQlkbWFfZnJlZV9jb2hlcmVudChtcC0+ZGV2LT5kZXYucGFyZW50LCB0eHEtPnR4X2Rlc2NfYXJlYV9zaXplLAorCQkJCSAgdHhxLT50eF9kZXNjX2FyZWEsIHR4cS0+dHhfZGVzY19kbWEpOworCXJldHVybiByZXQ7CiB9CiAKIHN0YXRpYyB2b2lkIHR4cV9kZWluaXQoc3RydWN0IHR4X3F1ZXVlICp0eHEpCkBAIC0yMDc3LDYgKzIxMTQsOCBAQAogCWVsc2UKIAkJZG1hX2ZyZWVfY29oZXJlbnQobXAtPmRldi0+ZGV2LnBhcmVudCwgdHhxLT50eF9kZXNjX2FyZWFfc2l6ZSwKIAkJCQkgIHR4cS0+dHhfZGVzY19hcmVhLCB0eHEtPnR4X2Rlc2NfZG1hKTsKKwlrZnJlZSh0eHEtPnR4X2Rlc2NfbWFwcGluZyk7CisKIAlpZiAodHhxLT50c29faGRycykKIAkJZG1hX2ZyZWVfY29oZXJlbnQobXAtPmRldi0+ZGV2LnBhcmVudCwKIAkJCQkgIHR4cS0+dHhfcmluZ19zaXplICogVFNPX0hFQURFUl9TSVpFLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvbWVsbGFub3gvbWx4NC9lbl9uZXRkZXYuYyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L21lbGxhbm94L21seDQvZW5fbmV0ZGV2LmMKaW5kZXggZDBkNmRjMS4uYWM2YThmMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvbWVsbGFub3gvbWx4NC9lbl9uZXRkZXYuYworKysgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9tZWxsYW5veC9tbHg0L2VuX25ldGRldi5jCkBAIC00NzUsNyArNDc1LDggQEAKIHsKIAlpbnQgZXJyOwogCi0JaWYgKHByaXYtPm1kZXYtPmRldi0+Y2Fwcy50dW5uZWxfb2ZmbG9hZF9tb2RlICE9IE1MWDRfVFVOTkVMX09GRkxPQURfTU9ERV9WWExBTikKKwlpZiAocHJpdi0+bWRldi0+ZGV2LT5jYXBzLnR1bm5lbF9vZmZsb2FkX21vZGUgIT0gTUxYNF9UVU5ORUxfT0ZGTE9BRF9NT0RFX1ZYTEFOIHx8CisJICAgIHByaXYtPm1kZXYtPmRldi0+Y2Fwcy5kbWZzX2hpZ2hfc3RlZXJfbW9kZSA9PSBNTFg0X1NURUVSSU5HX0RNRlNfQTBfU1RBVElDKQogCQlyZXR1cm4gMDsgLyogZG8gbm90aGluZyAqLwogCiAJZXJyID0gbWx4NF90dW5uZWxfc3RlZXJfYWRkKHByaXYtPm1kZXYtPmRldiwgYWRkciwgcHJpdi0+cG9ydCwgcXBuLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvbWVsbGFub3gvbWx4NC9tYWluLmMgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9tZWxsYW5veC9tbHg0L21haW4uYwppbmRleCAwM2U5ZWIwLi42ZTA4MzUyIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9tZWxsYW5veC9tbHg0L21haW4uYworKysgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9tZWxsYW5veC9tbHg0L21haW4uYwpAQCAtMTc0NCw4ICsxNzQ0LDcgQEAKIAkJCQkgICAgICAgc3RydWN0IG1seDRfZGV2X2NhcCAqZGV2X2NhcCkKIHsKIAlpZiAoZGV2LT5jYXBzLnN0ZWVyaW5nX21vZGUgPT0gTUxYNF9TVEVFUklOR19NT0RFX0RFVklDRV9NQU5BR0VEICYmCi0JICAgIGRldl9jYXAtPmZsYWdzMiAmIE1MWDRfREVWX0NBUF9GTEFHMl9WWExBTl9PRkZMT0FEUyAmJgotCSAgICBkZXYtPmNhcHMuZG1mc19oaWdoX3N0ZWVyX21vZGUgIT0gTUxYNF9TVEVFUklOR19ETUZTX0EwX1NUQVRJQykKKwkgICAgZGV2X2NhcC0+ZmxhZ3MyICYgTUxYNF9ERVZfQ0FQX0ZMQUcyX1ZYTEFOX09GRkxPQURTKQogCQlkZXYtPmNhcHMudHVubmVsX29mZmxvYWRfbW9kZSA9IE1MWDRfVFVOTkVMX09GRkxPQURfTU9ERV9WWExBTjsKIAllbHNlCiAJCWRldi0+Y2Fwcy50dW5uZWxfb2ZmbG9hZF9tb2RlID0gTUxYNF9UVU5ORUxfT0ZGTE9BRF9NT0RFX05PTkU7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9tZWxsYW5veC9tbHg0L21seDQuaCBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L21lbGxhbm94L21seDQvbWx4NC5oCmluZGV4IGJkZDRlZWEuLjIxMDY5MWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L21lbGxhbm94L21seDQvbWx4NC5oCisrKyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L21lbGxhbm94L21seDQvbWx4NC5oCkBAIC0yMzUsNyArMjM1LDggQEAKIGV4dGVybiBpbnQgbWx4NF9sb2dfbnVtX21nbV9lbnRyeV9zaXplOwogZXh0ZXJuIGludCBsb2dfbXR0c19wZXJfc2VnOwogCi0jZGVmaW5lIE1MWDRfTUFYX05VTV9TTEFWRVMJKE1MWDRfTUFYX05VTV9QRiArIE1MWDRfTUFYX05VTV9WRikKKyNkZWZpbmUgTUxYNF9NQVhfTlVNX1NMQVZFUwkobWluKE1MWDRfTUFYX05VTV9QRiArIE1MWDRfTUFYX05VTV9WRiwgXAorCQkJCSAgICAgTUxYNF9NRlVOQ19NQVgpKQogI2RlZmluZSBBTExfU0xBVkVTIDB4ZmYKIAogc3RydWN0IG1seDRfYml0bWFwIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L25ldGVyaW9uL3MyaW8uYyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L25ldGVyaW9uL3MyaW8uYwppbmRleCBmNWU0YjgyLi5kYjBjN2E5IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9uZXRlcmlvbi9zMmlvLmMKKysrIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvbmV0ZXJpb24vczJpby5jCkBAIC02OTg3LDcgKzY5ODcsOSBAQAogCQkJaWYgKHNwLT5zMmlvX2VudHJpZXNbaV0uaW5fdXNlID09IE1TSVhfRkxHKSB7CiAJCQkJaWYgKHNwLT5zMmlvX2VudHJpZXNbaV0udHlwZSA9PQogCQkJCSAgICBNU0lYX1JJTkdfVFlQRSkgewotCQkJCQlzcHJpbnRmKHNwLT5kZXNjW2ldLCAiJXM6TVNJLVgtJWQtUlgiLAorCQkJCQlzbnByaW50ZihzcC0+ZGVzY1tpXSwKKwkJCQkJCXNpemVvZihzcC0+ZGVzY1tpXSksCisJCQkJCQkiJXM6TVNJLVgtJWQtUlgiLAogCQkJCQkJZGV2LT5uYW1lLCBpKTsKIAkJCQkJZXJyID0gcmVxdWVzdF9pcnEoc3AtPmVudHJpZXNbaV0udmVjdG9yLAogCQkJCQkJCSAgczJpb19tc2l4X3JpbmdfaGFuZGxlLApAQCAtNjk5Niw3ICs2OTk4LDkgQEAKIAkJCQkJCQkgIHNwLT5zMmlvX2VudHJpZXNbaV0uYXJnKTsKIAkJCQl9IGVsc2UgaWYgKHNwLT5zMmlvX2VudHJpZXNbaV0udHlwZSA9PQogCQkJCQkgICBNU0lYX0FMQVJNX1RZUEUpIHsKLQkJCQkJc3ByaW50ZihzcC0+ZGVzY1tpXSwgIiVzOk1TSS1YLSVkLVRYIiwKKwkJCQkJc25wcmludGYoc3AtPmRlc2NbaV0sCisJCQkJCQlzaXplb2Yoc3AtPmRlc2NbaV0pLAorCQkJCQkJIiVzOk1TSS1YLSVkLVRYIiwKIAkJCQkJCWRldi0+bmFtZSwgaSk7CiAJCQkJCWVyciA9IHJlcXVlc3RfaXJxKHNwLT5lbnRyaWVzW2ldLnZlY3RvciwKIAkJCQkJCQkgIHMyaW9fbXNpeF9maWZvX2hhbmRsZSwKQEAgLTgxNTQsNyArODE1OCw4IEBACiAJCQkgICIlczogVURQIEZyYWdtZW50YXRpb24gT2ZmbG9hZChVRk8pIGVuYWJsZWRcbiIsCiAJCQkgIGRldi0+bmFtZSk7CiAJLyogSW5pdGlhbGl6ZSBkZXZpY2UgbmFtZSAqLwotCXNwcmludGYoc3AtPm5hbWUsICIlcyBOZXRlcmlvbiAlcyIsIGRldi0+bmFtZSwgc3AtPnByb2R1Y3RfbmFtZSk7CisJc25wcmludGYoc3AtPm5hbWUsIHNpemVvZihzcC0+bmFtZSksICIlcyBOZXRlcmlvbiAlcyIsIGRldi0+bmFtZSwKKwkJIHNwLT5wcm9kdWN0X25hbWUpOwogCiAJaWYgKHZsYW5fdGFnX3N0cmlwKQogCQlzcC0+dmxhbl9zdHJpcF9mbGFnID0gMTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L3Fsb2dpYy9uZXR4ZW4vbmV0eGVuX25pY19tYWluLmMgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9xbG9naWMvbmV0eGVuL25ldHhlbl9uaWNfbWFpbi5jCmluZGV4IDYxMzAzNzUuLmM1MzFjOGEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L3Fsb2dpYy9uZXR4ZW4vbmV0eGVuX25pY19tYWluLmMKKysrIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvcWxvZ2ljL25ldHhlbi9uZXR4ZW5fbmljX21haW4uYwpAQCAtMjM4OCw3ICsyMzg4LDEwIEBACiAKIAl3b3JrX2RvbmUgPSBuZXR4ZW5fcHJvY2Vzc19yY3ZfcmluZyhzZHNfcmluZywgYnVkZ2V0KTsKIAotCWlmICgod29ya19kb25lIDwgYnVkZ2V0KSAmJiB0eF9jb21wbGV0ZSkgeworCWlmICghdHhfY29tcGxldGUpCisJCXdvcmtfZG9uZSA9IGJ1ZGdldDsKKworCWlmICh3b3JrX2RvbmUgPCBidWRnZXQpIHsKIAkJbmFwaV9jb21wbGV0ZSgmc2RzX3JpbmctPm5hcGkpOwogCQlpZiAodGVzdF9iaXQoX19OWF9ERVZfVVAsICZhZGFwdGVyLT5zdGF0ZSkpCiAJCQluZXR4ZW5fbmljX2VuYWJsZV9pbnQoc2RzX3JpbmcpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvcWxvZ2ljL3FsY25pYy9xbGNuaWNfaW8uYyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L3Fsb2dpYy9xbGNuaWMvcWxjbmljX2lvLmMKaW5kZXggMThlNWRlNy4uNGUxZjU4YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvcWxvZ2ljL3FsY25pYy9xbGNuaWNfaW8uYworKysgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9xbG9naWMvcWxjbmljL3FsY25pY19pby5jCkBAIC05NjcsNyArOTY3LDEyIEBACiAJdHhfY29tcGxldGUgPSBxbGNuaWNfcHJvY2Vzc19jbWRfcmluZyhhZGFwdGVyLCB0eF9yaW5nLAogCQkJCQkgICAgICBidWRnZXQpOwogCXdvcmtfZG9uZSA9IHFsY25pY19wcm9jZXNzX3Jjdl9yaW5nKHNkc19yaW5nLCBidWRnZXQpOwotCWlmICgod29ya19kb25lIDwgYnVkZ2V0KSAmJiB0eF9jb21wbGV0ZSkgeworCisJLyogQ2hlY2sgaWYgd2UgbmVlZCBhIHJlcG9sbCAqLworCWlmICghdHhfY29tcGxldGUpCisJCXdvcmtfZG9uZSA9IGJ1ZGdldDsKKworCWlmICh3b3JrX2RvbmUgPCBidWRnZXQpIHsKIAkJbmFwaV9jb21wbGV0ZSgmc2RzX3JpbmctPm5hcGkpOwogCQlpZiAodGVzdF9iaXQoX19RTENOSUNfREVWX1VQLCAmYWRhcHRlci0+c3RhdGUpKSB7CiAJCQlxbGNuaWNfZW5hYmxlX3Nkc19pbnRyKGFkYXB0ZXIsIHNkc19yaW5nKTsKQEAgLTk5Miw2ICs5OTcsOSBAQAogCQluYXBpX2NvbXBsZXRlKCZ0eF9yaW5nLT5uYXBpKTsKIAkJaWYgKHRlc3RfYml0KF9fUUxDTklDX0RFVl9VUCwgJmFkYXB0ZXItPnN0YXRlKSkKIAkJCXFsY25pY19lbmFibGVfdHhfaW50cihhZGFwdGVyLCB0eF9yaW5nKTsKKwl9IGVsc2UgeworCQkvKiBBcyBxbGNuaWNfcHJvY2Vzc19jbWRfcmluZygpIHJldHVybmVkIDAsIHdlIG5lZWQgYSByZXBvbGwqLworCQl3b3JrX2RvbmUgPSBidWRnZXQ7CiAJfQogCiAJcmV0dXJuIHdvcmtfZG9uZTsKQEAgLTE5NTAsNyArMTk1OCwxMiBAQAogCiAJdHhfY29tcGxldGUgPSBxbGNuaWNfcHJvY2Vzc19jbWRfcmluZyhhZGFwdGVyLCB0eF9yaW5nLCBidWRnZXQpOwogCXdvcmtfZG9uZSA9IHFsY25pY184M3h4X3Byb2Nlc3NfcmN2X3Jpbmcoc2RzX3JpbmcsIGJ1ZGdldCk7Ci0JaWYgKCh3b3JrX2RvbmUgPCBidWRnZXQpICYmIHR4X2NvbXBsZXRlKSB7CisKKwkvKiBDaGVjayBpZiB3ZSBuZWVkIGEgcmVwb2xsICovCisJaWYgKCF0eF9jb21wbGV0ZSkKKwkJd29ya19kb25lID0gYnVkZ2V0OworCisJaWYgKHdvcmtfZG9uZSA8IGJ1ZGdldCkgewogCQluYXBpX2NvbXBsZXRlKCZzZHNfcmluZy0+bmFwaSk7CiAJCXFsY25pY19lbmFibGVfc2RzX2ludHIoYWRhcHRlciwgc2RzX3JpbmcpOwogCX0KQEAgLTE5NzMsNyArMTk4NiwxMiBAQAogCiAJdHhfY29tcGxldGUgPSBxbGNuaWNfcHJvY2Vzc19jbWRfcmluZyhhZGFwdGVyLCB0eF9yaW5nLCBidWRnZXQpOwogCXdvcmtfZG9uZSA9IHFsY25pY184M3h4X3Byb2Nlc3NfcmN2X3Jpbmcoc2RzX3JpbmcsIGJ1ZGdldCk7Ci0JaWYgKCh3b3JrX2RvbmUgPCBidWRnZXQpICYmIHR4X2NvbXBsZXRlKSB7CisKKwkvKiBDaGVjayBpZiB3ZSBuZWVkIGEgcmVwb2xsICovCisJaWYgKCF0eF9jb21wbGV0ZSkKKwkJd29ya19kb25lID0gYnVkZ2V0OworCisJaWYgKHdvcmtfZG9uZSA8IGJ1ZGdldCkgewogCQluYXBpX2NvbXBsZXRlKCZzZHNfcmluZy0+bmFwaSk7CiAJCXFsY25pY19lbmFibGVfc2RzX2ludHIoYWRhcHRlciwgc2RzX3JpbmcpOwogCX0KQEAgLTE5OTUsNiArMjAxMyw5IEBACiAJCW5hcGlfY29tcGxldGUoJnR4X3JpbmctPm5hcGkpOwogCQlpZiAodGVzdF9iaXQoX19RTENOSUNfREVWX1VQICwgJmFkYXB0ZXItPnN0YXRlKSkKIAkJCXFsY25pY19lbmFibGVfdHhfaW50cihhZGFwdGVyLCB0eF9yaW5nKTsKKwl9IGVsc2UgeworCQkvKiBuZWVkIGEgcmVwb2xsICovCisJCXdvcmtfZG9uZSA9IGJ1ZGdldDsKIAl9CiAKIAlyZXR1cm4gd29ya19kb25lOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvcWxvZ2ljL3FsZ2UvcWxnZV9tYWluLmMgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9xbG9naWMvcWxnZS9xbGdlX21haW4uYwppbmRleCA2YzkwNGE2Li5lZjVhZWQzIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9xbG9naWMvcWxnZS9xbGdlX21haW4uYworKysgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9xbG9naWMvcWxnZS9xbGdlX21haW4uYwpAQCAtMjM1MSwyMyArMjM1MSwyOSBAQAogewogCXN0cnVjdCBxbF9hZGFwdGVyICpxZGV2ID0gbmV0ZGV2X3ByaXYobmRldik7CiAJaW50IHN0YXR1cyA9IDA7CisJYm9vbCBuZWVkX3Jlc3RhcnQgPSBuZXRpZl9ydW5uaW5nKG5kZXYpOwogCi0Jc3RhdHVzID0gcWxfYWRhcHRlcl9kb3duKHFkZXYpOwotCWlmIChzdGF0dXMpIHsKLQkJbmV0aWZfZXJyKHFkZXYsIGxpbmssIHFkZXYtPm5kZXYsCi0JCQkgICJGYWlsZWQgdG8gYnJpbmcgZG93biB0aGUgYWRhcHRlclxuIik7Ci0JCXJldHVybiBzdGF0dXM7CisJaWYgKG5lZWRfcmVzdGFydCkgeworCQlzdGF0dXMgPSBxbF9hZGFwdGVyX2Rvd24ocWRldik7CisJCWlmIChzdGF0dXMpIHsKKwkJCW5ldGlmX2VycihxZGV2LCBsaW5rLCBxZGV2LT5uZGV2LAorCQkJCSAgIkZhaWxlZCB0byBicmluZyBkb3duIHRoZSBhZGFwdGVyXG4iKTsKKwkJCXJldHVybiBzdGF0dXM7CisJCX0KIAl9CiAKIAkvKiB1cGRhdGUgdGhlIGZlYXR1cmVzIHdpdGggcmVzZW50IGNoYW5nZSAqLwogCW5kZXYtPmZlYXR1cmVzID0gZmVhdHVyZXM7CiAKLQlzdGF0dXMgPSBxbF9hZGFwdGVyX3VwKHFkZXYpOwotCWlmIChzdGF0dXMpIHsKLQkJbmV0aWZfZXJyKHFkZXYsIGxpbmssIHFkZXYtPm5kZXYsCi0JCQkgICJGYWlsZWQgdG8gYnJpbmcgdXAgdGhlIGFkYXB0ZXJcbiIpOwotCQlyZXR1cm4gc3RhdHVzOworCWlmIChuZWVkX3Jlc3RhcnQpIHsKKwkJc3RhdHVzID0gcWxfYWRhcHRlcl91cChxZGV2KTsKKwkJaWYgKHN0YXR1cykgeworCQkJbmV0aWZfZXJyKHFkZXYsIGxpbmssIHFkZXYtPm5kZXYsCisJCQkJICAiRmFpbGVkIHRvIGJyaW5nIHVwIHRoZSBhZGFwdGVyXG4iKTsKKwkJCXJldHVybiBzdGF0dXM7CisJCX0KIAl9CisKIAlyZXR1cm4gc3RhdHVzOwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9yZW5lc2FzL3NoX2V0aC5jIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvcmVuZXNhcy9zaF9ldGguYwppbmRleCAzNzU4M2E5Li4wNDI4M2ZlIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9yZW5lc2FzL3NoX2V0aC5jCisrKyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L3JlbmVzYXMvc2hfZXRoLmMKQEAgLTM5Niw2ICszOTYsOSBAQAogCVtUU1VfQURSTDMxXQk9IDB4MDFmYywKIH07CiAKK3N0YXRpYyB2b2lkIHNoX2V0aF9yY3Zfc25kX2Rpc2FibGUoc3RydWN0IG5ldF9kZXZpY2UgKm5kZXYpOworc3RhdGljIHN0cnVjdCBuZXRfZGV2aWNlX3N0YXRzICpzaF9ldGhfZ2V0X3N0YXRzKHN0cnVjdCBuZXRfZGV2aWNlICpuZGV2KTsKKwogc3RhdGljIGJvb2wgc2hfZXRoX2lzX2dldGhlcihzdHJ1Y3Qgc2hfZXRoX3ByaXZhdGUgKm1kcCkKIHsKIAlyZXR1cm4gbWRwLT5yZWdfb2Zmc2V0ID09IHNoX2V0aF9vZmZzZXRfZ2lnYWJpdDsKQEAgLTQ5OCw2ICs1MDEsOCBAQAogCQkJICBFRVNSX0VDSSwKIAkuZmRyX3ZhbHVlCT0gMHgwMDAwMGYwZiwKIAorCS50cnNjZXJfZXJyX21hc2sgPSBERVNDX0lfUklOVDgsCisKIAkuYXByCQk9IDEsCiAJLm1wcgkJPSAxLAogCS50cGF1c2VyCT0gMSwKQEAgLTUzOCw4ICs1NDMsNiBAQAogCQkJICBFRVNSX1JERSB8IEVFU1JfUkZSTUVSIHwgRUVTUl9URkUgfCBFRVNSX1RERSB8CiAJCQkgIEVFU1JfRUNJLAogCi0JLnRyc2Nlcl9lcnJfbWFzayA9IERFU0NfSV9SSU5UOCwKLQogCS5hcHIJCT0gMSwKIAkubXByCQk9IDEsCiAJLnRwYXVzZXIJPSAxLApAQCAtMTEyMCw2ICsxMTIzLDcgQEAKIAlpbnQgcnhfcmluZ3NpemUgPSBzaXplb2YoKnJ4ZGVzYykgKiBtZHAtPm51bV9yeF9yaW5nOwogCWludCB0eF9yaW5nc2l6ZSA9IHNpemVvZigqdHhkZXNjKSAqIG1kcC0+bnVtX3R4X3Jpbmc7CiAJaW50IHNrYnVmZl9zaXplID0gbWRwLT5yeF9idWZfc3ogKyBTSF9FVEhfUlhfQUxJR04gLSAxOworCWRtYV9hZGRyX3QgZG1hX2FkZHI7CiAKIAltZHAtPmN1cl9yeCA9IDA7CiAJbWRwLT5jdXJfdHggPSAwOwpAQCAtMTEzMyw3ICsxMTM3LDYgQEAKIAkJLyogc2tiICovCiAJCW1kcC0+cnhfc2tidWZmW2ldID0gTlVMTDsKIAkJc2tiID0gbmV0ZGV2X2FsbG9jX3NrYihuZGV2LCBza2J1ZmZfc2l6ZSk7Ci0JCW1kcC0+cnhfc2tidWZmW2ldID0gc2tiOwogCQlpZiAoc2tiID09IE5VTEwpCiAJCQlicmVhazsKIAkJc2hfZXRoX3NldF9yZWNlaXZlX2FsaWduKHNrYik7CkBAIC0xMTQyLDkgKzExNDUsMTUgQEAKIAkJcnhkZXNjID0gJm1kcC0+cnhfcmluZ1tpXTsKIAkJLyogVGhlIHNpemUgb2YgdGhlIGJ1ZmZlciBpcyBhIG11bHRpcGxlIG9mIDE2IGJ5dGVzLiAqLwogCQlyeGRlc2MtPmJ1ZmZlcl9sZW5ndGggPSBBTElHTihtZHAtPnJ4X2J1Zl9zeiwgMTYpOwotCQlkbWFfbWFwX3NpbmdsZSgmbmRldi0+ZGV2LCBza2ItPmRhdGEsIHJ4ZGVzYy0+YnVmZmVyX2xlbmd0aCwKLQkJCSAgICAgICBETUFfRlJPTV9ERVZJQ0UpOwotCQlyeGRlc2MtPmFkZHIgPSB2aXJ0X3RvX3BoeXMoc2tiLT5kYXRhKTsKKwkJZG1hX2FkZHIgPSBkbWFfbWFwX3NpbmdsZSgmbmRldi0+ZGV2LCBza2ItPmRhdGEsCisJCQkJCSAgcnhkZXNjLT5idWZmZXJfbGVuZ3RoLAorCQkJCQkgIERNQV9GUk9NX0RFVklDRSk7CisJCWlmIChkbWFfbWFwcGluZ19lcnJvcigmbmRldi0+ZGV2LCBkbWFfYWRkcikpIHsKKwkJCWtmcmVlX3NrYihza2IpOworCQkJYnJlYWs7CisJCX0KKwkJbWRwLT5yeF9za2J1ZmZbaV0gPSBza2I7CisJCXJ4ZGVzYy0+YWRkciA9IGRtYV9hZGRyOwogCQlyeGRlc2MtPnN0YXR1cyA9IGNwdV90b19lZG1hYyhtZHAsIFJEX1JBQ1QgfCBSRF9SRlApOwogCiAJCS8qIFJ4IGRlc2NyaXB0b3IgYWRkcmVzcyBzZXQgKi8KQEAgLTEzMTYsOCArMTMyNSwxMCBAQAogCQkgICAgIFJGTFIpOwogCiAJc2hfZXRoX3dyaXRlKG5kZXYsIHNoX2V0aF9yZWFkKG5kZXYsIEVFU1IpLCBFRVNSKTsKLQlpZiAoc3RhcnQpCisJaWYgKHN0YXJ0KSB7CisJCW1kcC0+aXJxX2VuYWJsZWQgPSB0cnVlOwogCQlzaF9ldGhfd3JpdGUobmRldiwgbWRwLT5jZC0+ZWVzaXByX3ZhbHVlLCBFRVNJUFIpOworCX0KIAogCS8qIFBBVVNFIFByb2hpYml0aW9uICovCiAJdmFsID0gKHNoX2V0aF9yZWFkKG5kZXYsIEVDTVIpICYgRUNNUl9ETSkgfApAQCAtMTM1Niw2ICsxMzY3LDMzIEBACiAJcmV0dXJuIHJldDsKIH0KIAorc3RhdGljIHZvaWQgc2hfZXRoX2Rldl9leGl0KHN0cnVjdCBuZXRfZGV2aWNlICpuZGV2KQoreworCXN0cnVjdCBzaF9ldGhfcHJpdmF0ZSAqbWRwID0gbmV0ZGV2X3ByaXYobmRldik7CisJaW50IGk7CisKKwkvKiBEZWFjdGl2YXRlIGFsbCBUWCBkZXNjcmlwdG9ycywgc28gRE1BIHNob3VsZCBzdG9wIGF0IG5leHQKKwkgKiBwYWNrZXQgYm91bmRhcnkgaWYgaXQncyBjdXJyZW50bHkgcnVubmluZworCSAqLworCWZvciAoaSA9IDA7IGkgPCBtZHAtPm51bV90eF9yaW5nOyBpKyspCisJCW1kcC0+dHhfcmluZ1tpXS5zdGF0dXMgJj0gfmNwdV90b19lZG1hYyhtZHAsIFREX1RBQ1QpOworCisJLyogRGlzYWJsZSBUWCBGSUZPIGVncmVzcyB0byBNQUMgKi8KKwlzaF9ldGhfcmN2X3NuZF9kaXNhYmxlKG5kZXYpOworCisJLyogU3RvcCBSWCBETUEgYXQgbmV4dCBwYWNrZXQgYm91bmRhcnkgKi8KKwlzaF9ldGhfd3JpdGUobmRldiwgMCwgRURSUlIpOworCisJLyogQXNpZGUgZnJvbSBUWCBETUEsIHdlIGNhbid0IHRlbGwgd2hlbiB0aGUgaGFyZHdhcmUgaXMKKwkgKiByZWFsbHkgc3RvcHBlZCwgc28gd2UgbmVlZCB0byByZXNldCB0byBtYWtlIHN1cmUuCisJICogQmVmb3JlIGRvaW5nIHRoYXQsIHdhaXQgZm9yIGxvbmcgZW5vdWdoIHRvICpwcm9iYWJseSoKKwkgKiBmaW5pc2ggdHJhbnNtaXR0aW5nIHRoZSBsYXN0IHBhY2tldCBhbmQgcG9sbCBzdGF0cy4KKwkgKi8KKwltc2xlZXAoMik7IC8qIG1heCBmcmFtZSB0aW1lIGF0IDEwIE1icHMgPCAxMjUwIHVzICovCisJc2hfZXRoX2dldF9zdGF0cyhuZGV2KTsKKwlzaF9ldGhfcmVzZXQobmRldik7Cit9CisKIC8qIGZyZWUgVHggc2tiIGZ1bmN0aW9uICovCiBzdGF0aWMgaW50IHNoX2V0aF90eGZyZWUoc3RydWN0IG5ldF9kZXZpY2UgKm5kZXYpCiB7CkBAIC0xNDAwLDYgKzE0MzgsNyBAQAogCXUxNiBwa3RfbGVuID0gMDsKIAl1MzIgZGVzY19zdGF0dXM7CiAJaW50IHNrYnVmZl9zaXplID0gbWRwLT5yeF9idWZfc3ogKyBTSF9FVEhfUlhfQUxJR04gLSAxOworCWRtYV9hZGRyX3QgZG1hX2FkZHI7CiAKIAlib2d1c2NudCA9IG1pbihib2d1c2NudCwgKnF1b3RhKTsKIAlsaW1pdCA9IGJvZ3VzY250OwpAQCAtMTQ0Nyw5ICsxNDg2LDkgQEAKIAkJCW1kcC0+cnhfc2tidWZmW2VudHJ5XSA9IE5VTEw7CiAJCQlpZiAobWRwLT5jZC0+cnBhZGlyKQogCQkJCXNrYl9yZXNlcnZlKHNrYiwgTkVUX0lQX0FMSUdOKTsKLQkJCWRtYV9zeW5jX3NpbmdsZV9mb3JfY3B1KCZuZGV2LT5kZXYsIHJ4ZGVzYy0+YWRkciwKLQkJCQkJCUFMSUdOKG1kcC0+cnhfYnVmX3N6LCAxNiksCi0JCQkJCQlETUFfRlJPTV9ERVZJQ0UpOworCQkJZG1hX3VubWFwX3NpbmdsZSgmbmRldi0+ZGV2LCByeGRlc2MtPmFkZHIsCisJCQkJCSBBTElHTihtZHAtPnJ4X2J1Zl9zeiwgMTYpLAorCQkJCQkgRE1BX0ZST01fREVWSUNFKTsKIAkJCXNrYl9wdXQoc2tiLCBwa3RfbGVuKTsKIAkJCXNrYi0+cHJvdG9jb2wgPSBldGhfdHlwZV90cmFucyhza2IsIG5kZXYpOwogCQkJbmV0aWZfcmVjZWl2ZV9za2Ioc2tiKTsKQEAgLTE0NjksMTUgKzE1MDgsMjAgQEAKIAogCQlpZiAobWRwLT5yeF9za2J1ZmZbZW50cnldID09IE5VTEwpIHsKIAkJCXNrYiA9IG5ldGRldl9hbGxvY19za2IobmRldiwgc2tidWZmX3NpemUpOwotCQkJbWRwLT5yeF9za2J1ZmZbZW50cnldID0gc2tiOwogCQkJaWYgKHNrYiA9PSBOVUxMKQogCQkJCWJyZWFrOwkvKiBCZXR0ZXIgbHVjayBuZXh0IHJvdW5kLiAqLwogCQkJc2hfZXRoX3NldF9yZWNlaXZlX2FsaWduKHNrYik7Ci0JCQlkbWFfbWFwX3NpbmdsZSgmbmRldi0+ZGV2LCBza2ItPmRhdGEsCi0JCQkJICAgICAgIHJ4ZGVzYy0+YnVmZmVyX2xlbmd0aCwgRE1BX0ZST01fREVWSUNFKTsKKwkJCWRtYV9hZGRyID0gZG1hX21hcF9zaW5nbGUoJm5kZXYtPmRldiwgc2tiLT5kYXRhLAorCQkJCQkJICByeGRlc2MtPmJ1ZmZlcl9sZW5ndGgsCisJCQkJCQkgIERNQV9GUk9NX0RFVklDRSk7CisJCQlpZiAoZG1hX21hcHBpbmdfZXJyb3IoJm5kZXYtPmRldiwgZG1hX2FkZHIpKSB7CisJCQkJa2ZyZWVfc2tiKHNrYik7CisJCQkJYnJlYWs7CisJCQl9CisJCQltZHAtPnJ4X3NrYnVmZltlbnRyeV0gPSBza2I7CiAKIAkJCXNrYl9jaGVja3N1bV9ub25lX2Fzc2VydChza2IpOwotCQkJcnhkZXNjLT5hZGRyID0gdmlydF90b19waHlzKHNrYi0+ZGF0YSk7CisJCQlyeGRlc2MtPmFkZHIgPSBkbWFfYWRkcjsKIAkJfQogCQlpZiAoZW50cnkgPj0gbWRwLT5udW1fcnhfcmluZyAtIDEpCiAJCQlyeGRlc2MtPnN0YXR1cyB8PQpAQCAtMTU3Myw3ICsxNjE3LDYgQEAKIAkJaWYgKGludHJfc3RhdHVzICYgRUVTUl9SRlJNRVIpIHsKIAkJCS8qIFJlY2VpdmUgRnJhbWUgT3ZlcmZsb3cgaW50ICovCiAJCQluZGV2LT5zdGF0cy5yeF9mcmFtZV9lcnJvcnMrKzsKLQkJCW5ldGlmX2VycihtZHAsIHJ4X2VyciwgbmRldiwgIlJlY2VpdmUgQWJvcnRcbiIpOwogCQl9CiAJfQogCkBAIC0xNTkyLDEzICsxNjM1LDExIEBACiAJaWYgKGludHJfc3RhdHVzICYgRUVTUl9SREUpIHsKIAkJLyogUmVjZWl2ZSBEZXNjcmlwdG9yIEVtcHR5IGludCAqLwogCQluZGV2LT5zdGF0cy5yeF9vdmVyX2Vycm9ycysrOwotCQluZXRpZl9lcnIobWRwLCByeF9lcnIsIG5kZXYsICJSZWNlaXZlIERlc2NyaXB0b3IgRW1wdHlcbiIpOwogCX0KIAogCWlmIChpbnRyX3N0YXR1cyAmIEVFU1JfUkZFKSB7CiAJCS8qIFJlY2VpdmUgRklGTyBPdmVyZmxvdyBpbnQgKi8KIAkJbmRldi0+c3RhdHMucnhfZmlmb19lcnJvcnMrKzsKLQkJbmV0aWZfZXJyKG1kcCwgcnhfZXJyLCBuZGV2LCAiUmVjZWl2ZSBGSUZPIE92ZXJmbG93XG4iKTsKIAl9CiAKIAlpZiAoIW1kcC0+Y2QtPm5vX2FkZSAmJiAoaW50cl9zdGF0dXMgJiBFRVNSX0FERSkpIHsKQEAgLTE2NTMsNyArMTY5NCwxMiBAQAogCWlmIChpbnRyX3N0YXR1cyAmIChFRVNSX1JYX0NIRUNLIHwgY2QtPnR4X2NoZWNrIHwgY2QtPmVlc3JfZXJyX2NoZWNrKSkKIAkJcmV0ID0gSVJRX0hBTkRMRUQ7CiAJZWxzZQotCQlnb3RvIG90aGVyX2lycTsKKwkJZ290byBvdXQ7CisKKwlpZiAoIWxpa2VseShtZHAtPmlycV9lbmFibGVkKSkgeworCQlzaF9ldGhfd3JpdGUobmRldiwgMCwgRUVTSVBSKTsKKwkJZ290byBvdXQ7CisJfQogCiAJaWYgKGludHJfc3RhdHVzICYgRUVTUl9SWF9DSEVDSykgewogCQlpZiAobmFwaV9zY2hlZHVsZV9wcmVwKCZtZHAtPm5hcGkpKSB7CkBAIC0xNjg0LDcgKzE3MzAsNyBAQAogCQlzaF9ldGhfZXJyb3IobmRldiwgaW50cl9zdGF0dXMpOwogCX0KIAotb3RoZXJfaXJxOgorb3V0OgogCXNwaW5fdW5sb2NrKCZtZHAtPmxvY2spOwogCiAJcmV0dXJuIHJldDsKQEAgLTE3MTIsNyArMTc1OCw4IEBACiAJbmFwaV9jb21wbGV0ZShuYXBpKTsKIAogCS8qIFJlZW5hYmxlIFJ4IGludGVycnVwdHMgKi8KLQlzaF9ldGhfd3JpdGUobmRldiwgbWRwLT5jZC0+ZWVzaXByX3ZhbHVlLCBFRVNJUFIpOworCWlmIChtZHAtPmlycV9lbmFibGVkKQorCQlzaF9ldGhfd3JpdGUobmRldiwgbWRwLT5jZC0+ZWVzaXByX3ZhbHVlLCBFRVNJUFIpOwogb3V0OgogCXJldHVybiBidWRnZXQgLSBxdW90YTsKIH0KQEAgLTE4MjcsNiArMTg3NCw5IEBACiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAlpbnQgcmV0OwogCisJaWYgKCFtZHAtPnBoeWRldikKKwkJcmV0dXJuIC1FTk9ERVY7CisKIAlzcGluX2xvY2tfaXJxc2F2ZSgmbWRwLT5sb2NrLCBmbGFncyk7CiAJcmV0ID0gcGh5X2V0aHRvb2xfZ3NldChtZHAtPnBoeWRldiwgZWNtZCk7CiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmbWRwLT5sb2NrLCBmbGFncyk7CkBAIC0xODQxLDYgKzE4OTEsOSBAQAogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAJaW50IHJldDsKIAorCWlmICghbWRwLT5waHlkZXYpCisJCXJldHVybiAtRU5PREVWOworCiAJc3Bpbl9sb2NrX2lycXNhdmUoJm1kcC0+bG9jaywgZmxhZ3MpOwogCiAJLyogZGlzYWJsZSB0eCBhbmQgcnggKi8KQEAgLTE4NzUsNiArMTkyOCw5IEBACiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAlpbnQgcmV0OwogCisJaWYgKCFtZHAtPnBoeWRldikKKwkJcmV0dXJuIC1FTk9ERVY7CisKIAlzcGluX2xvY2tfaXJxc2F2ZSgmbWRwLT5sb2NrLCBmbGFncyk7CiAJcmV0ID0gcGh5X3N0YXJ0X2FuZWcobWRwLT5waHlkZXYpOwogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJm1kcC0+bG9jaywgZmxhZ3MpOwpAQCAtMTk1OSw0MCArMjAxNSw1MCBAQAogCQlyZXR1cm4gLUVJTlZBTDsKIAogCWlmIChuZXRpZl9ydW5uaW5nKG5kZXYpKSB7CisJCW5ldGlmX2RldmljZV9kZXRhY2gobmRldik7CiAJCW5ldGlmX3R4X2Rpc2FibGUobmRldik7Ci0JCS8qIERpc2FibGUgaW50ZXJydXB0cyBieSBjbGVhcmluZyB0aGUgaW50ZXJydXB0IG1hc2suICovCi0JCXNoX2V0aF93cml0ZShuZGV2LCAweDAwMDAsIEVFU0lQUik7Ci0JCS8qIFN0b3AgdGhlIGNoaXAncyBUeCBhbmQgUnggcHJvY2Vzc2VzLiAqLwotCQlzaF9ldGhfd3JpdGUobmRldiwgMCwgRURUUlIpOwotCQlzaF9ldGhfd3JpdGUobmRldiwgMCwgRURSUlIpOwotCQlzeW5jaHJvbml6ZV9pcnEobmRldi0+aXJxKTsKLQl9CiAKLQkvKiBGcmVlIGFsbCB0aGUgc2tidWZmcyBpbiB0aGUgUnggcXVldWUuICovCi0Jc2hfZXRoX3JpbmdfZnJlZShuZGV2KTsKLQkvKiBGcmVlIERNQSBidWZmZXIgKi8KLQlzaF9ldGhfZnJlZV9kbWFfYnVmZmVyKG1kcCk7CisJCS8qIFNlcmlhbGlzZSB3aXRoIHRoZSBpbnRlcnJ1cHQgaGFuZGxlciBhbmQgTkFQSSwgdGhlbgorCQkgKiBkaXNhYmxlIGludGVycnVwdHMuICBXZSBoYXZlIHRvIGNsZWFyIHRoZQorCQkgKiBpcnFfZW5hYmxlZCBmbGFnIGZpcnN0IHRvIGVuc3VyZSB0aGF0IGludGVycnVwdHMKKwkJICogd29uJ3QgYmUgcmUtZW5hYmxlZC4KKwkJICovCisJCW1kcC0+aXJxX2VuYWJsZWQgPSBmYWxzZTsKKwkJc3luY2hyb25pemVfaXJxKG5kZXYtPmlycSk7CisJCW5hcGlfc3luY2hyb25pemUoJm1kcC0+bmFwaSk7CisJCXNoX2V0aF93cml0ZShuZGV2LCAweDAwMDAsIEVFU0lQUik7CisKKwkJc2hfZXRoX2Rldl9leGl0KG5kZXYpOworCisJCS8qIEZyZWUgYWxsIHRoZSBza2J1ZmZzIGluIHRoZSBSeCBxdWV1ZS4gKi8KKwkJc2hfZXRoX3JpbmdfZnJlZShuZGV2KTsKKwkJLyogRnJlZSBETUEgYnVmZmVyICovCisJCXNoX2V0aF9mcmVlX2RtYV9idWZmZXIobWRwKTsKKwl9CiAKIAkvKiBTZXQgbmV3IHBhcmFtZXRlcnMgKi8KIAltZHAtPm51bV9yeF9yaW5nID0gcmluZy0+cnhfcGVuZGluZzsKIAltZHAtPm51bV90eF9yaW5nID0gcmluZy0+dHhfcGVuZGluZzsKIAotCXJldCA9IHNoX2V0aF9yaW5nX2luaXQobmRldik7Ci0JaWYgKHJldCA8IDApIHsKLQkJbmV0ZGV2X2VycihuZGV2LCAiJXM6IHNoX2V0aF9yaW5nX2luaXQgZmFpbGVkLlxuIiwgX19mdW5jX18pOwotCQlyZXR1cm4gcmV0OwotCX0KLQlyZXQgPSBzaF9ldGhfZGV2X2luaXQobmRldiwgZmFsc2UpOwotCWlmIChyZXQgPCAwKSB7Ci0JCW5ldGRldl9lcnIobmRldiwgIiVzOiBzaF9ldGhfZGV2X2luaXQgZmFpbGVkLlxuIiwgX19mdW5jX18pOwotCQlyZXR1cm4gcmV0OwotCX0KLQogCWlmIChuZXRpZl9ydW5uaW5nKG5kZXYpKSB7CisJCXJldCA9IHNoX2V0aF9yaW5nX2luaXQobmRldik7CisJCWlmIChyZXQgPCAwKSB7CisJCQluZXRkZXZfZXJyKG5kZXYsICIlczogc2hfZXRoX3JpbmdfaW5pdCBmYWlsZWQuXG4iLAorCQkJCSAgIF9fZnVuY19fKTsKKwkJCXJldHVybiByZXQ7CisJCX0KKwkJcmV0ID0gc2hfZXRoX2Rldl9pbml0KG5kZXYsIGZhbHNlKTsKKwkJaWYgKHJldCA8IDApIHsKKwkJCW5ldGRldl9lcnIobmRldiwgIiVzOiBzaF9ldGhfZGV2X2luaXQgZmFpbGVkLlxuIiwKKwkJCQkgICBfX2Z1bmNfXyk7CisJCQlyZXR1cm4gcmV0OworCQl9CisKKwkJbWRwLT5pcnFfZW5hYmxlZCA9IHRydWU7CiAJCXNoX2V0aF93cml0ZShuZGV2LCBtZHAtPmNkLT5lZXNpcHJfdmFsdWUsIEVFU0lQUik7CiAJCS8qIFNldHRpbmcgdGhlIFJ4IG1vZGUgd2lsbCBzdGFydCB0aGUgUnggcHJvY2Vzcy4gKi8KIAkJc2hfZXRoX3dyaXRlKG5kZXYsIEVEUlJSX1IsIEVEUlJSKTsKLQkJbmV0aWZfd2FrZV9xdWV1ZShuZGV2KTsKKwkJbmV0aWZfZGV2aWNlX2F0dGFjaChuZGV2KTsKIAl9CiAKIAlyZXR1cm4gMDsKQEAgLTIxMDgsNiArMjE3NCw5IEBACiAJfQogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJm1kcC0+bG9jaywgZmxhZ3MpOwogCisJaWYgKHNrYl9wYWR0byhza2IsIEVUSF9aTEVOKSkKKwkJcmV0dXJuIE5FVERFVl9UWF9PSzsKKwogCWVudHJ5ID0gbWRwLT5jdXJfdHggJSBtZHAtPm51bV90eF9yaW5nOwogCW1kcC0+dHhfc2tidWZmW2VudHJ5XSA9IHNrYjsKIAl0eGRlc2MgPSAmbWRwLT50eF9yaW5nW2VudHJ5XTsKQEAgLTIxMTcsMTAgKzIxODYsMTEgQEAKIAkJCQkgc2tiLT5sZW4gKyAyKTsKIAl0eGRlc2MtPmFkZHIgPSBkbWFfbWFwX3NpbmdsZSgmbmRldi0+ZGV2LCBza2ItPmRhdGEsIHNrYi0+bGVuLAogCQkJCSAgICAgIERNQV9UT19ERVZJQ0UpOwotCWlmIChza2ItPmxlbiA8IEVUSF9aTEVOKQotCQl0eGRlc2MtPmJ1ZmZlcl9sZW5ndGggPSBFVEhfWkxFTjsKLQllbHNlCi0JCXR4ZGVzYy0+YnVmZmVyX2xlbmd0aCA9IHNrYi0+bGVuOworCWlmIChkbWFfbWFwcGluZ19lcnJvcigmbmRldi0+ZGV2LCB0eGRlc2MtPmFkZHIpKSB7CisJCWtmcmVlX3NrYihza2IpOworCQlyZXR1cm4gTkVUREVWX1RYX09LOworCX0KKwl0eGRlc2MtPmJ1ZmZlcl9sZW5ndGggPSBza2ItPmxlbjsKIAogCWlmIChlbnRyeSA+PSBtZHAtPm51bV90eF9yaW5nIC0gMSkKIAkJdHhkZXNjLT5zdGF0dXMgfD0gY3B1X3RvX2VkbWFjKG1kcCwgVERfVEFDVCB8IFREX1RETEUpOwpAQCAtMjE3MiwyNCArMjI0MiwyNiBAQAogCiAJbmV0aWZfc3RvcF9xdWV1ZShuZGV2KTsKIAotCS8qIERpc2FibGUgaW50ZXJydXB0cyBieSBjbGVhcmluZyB0aGUgaW50ZXJydXB0IG1hc2suICovCisJLyogU2VyaWFsaXNlIHdpdGggdGhlIGludGVycnVwdCBoYW5kbGVyIGFuZCBOQVBJLCB0aGVuIGRpc2FibGUKKwkgKiBpbnRlcnJ1cHRzLiAgV2UgaGF2ZSB0byBjbGVhciB0aGUgaXJxX2VuYWJsZWQgZmxhZyBmaXJzdCB0bworCSAqIGVuc3VyZSB0aGF0IGludGVycnVwdHMgd29uJ3QgYmUgcmUtZW5hYmxlZC4KKwkgKi8KKwltZHAtPmlycV9lbmFibGVkID0gZmFsc2U7CisJc3luY2hyb25pemVfaXJxKG5kZXYtPmlycSk7CisJbmFwaV9kaXNhYmxlKCZtZHAtPm5hcGkpOwogCXNoX2V0aF93cml0ZShuZGV2LCAweDAwMDAsIEVFU0lQUik7CiAKLQkvKiBTdG9wIHRoZSBjaGlwJ3MgVHggYW5kIFJ4IHByb2Nlc3Nlcy4gKi8KLQlzaF9ldGhfd3JpdGUobmRldiwgMCwgRURUUlIpOwotCXNoX2V0aF93cml0ZShuZGV2LCAwLCBFRFJSUik7CisJc2hfZXRoX2Rldl9leGl0KG5kZXYpOwogCi0Jc2hfZXRoX2dldF9zdGF0cyhuZGV2KTsKIAkvKiBQSFkgRGlzY29ubmVjdCAqLwogCWlmIChtZHAtPnBoeWRldikgewogCQlwaHlfc3RvcChtZHAtPnBoeWRldik7CiAJCXBoeV9kaXNjb25uZWN0KG1kcC0+cGh5ZGV2KTsKKwkJbWRwLT5waHlkZXYgPSBOVUxMOwogCX0KIAogCWZyZWVfaXJxKG5kZXYtPmlycSwgbmRldik7CiAKLQluYXBpX2Rpc2FibGUoJm1kcC0+bmFwaSk7Ci0KIAkvKiBGcmVlIGFsbCB0aGUgc2tidWZmcyBpbiB0aGUgUnggcXVldWUuICovCiAJc2hfZXRoX3JpbmdfZnJlZShuZGV2KTsKIApAQCAtMjQxNyw3ICsyNDg5LDcgQEAKIAlzdHJ1Y3Qgc2hfZXRoX3ByaXZhdGUgKm1kcCA9IG5ldGRldl9wcml2KG5kZXYpOwogCWludCBpLCByZXQ7CiAKLQlpZiAodW5saWtlbHkoIW1kcC0+Y2QtPnRzdSkpCisJaWYgKCFtZHAtPmNkLT50c3UpCiAJCXJldHVybiAwOwogCiAJZm9yIChpID0gMDsgaSA8IFNIX0VUSF9UU1VfQ0FNX0VOVFJJRVM7IGkrKykgewpAQCAtMjQ0MCw3ICsyNTEyLDcgQEAKIAl2b2lkICpyZWdfb2Zmc2V0ID0gc2hfZXRoX3RzdV9nZXRfb2Zmc2V0KG1kcCwgVFNVX0FEUkgwKTsKIAlpbnQgaTsKIAotCWlmICh1bmxpa2VseSghbWRwLT5jZC0+dHN1KSkKKwlpZiAoIW1kcC0+Y2QtPnRzdSkKIAkJcmV0dXJuOwogCiAJZm9yIChpID0gMDsgaSA8IFNIX0VUSF9UU1VfQ0FNX0VOVFJJRVM7IGkrKywgcmVnX29mZnNldCArPSA4KSB7CkBAIC0yNDUwLDggKzI1MjIsOCBAQAogCX0KIH0KIAotLyogTXVsdGljYXN0IHJlY2VwdGlvbiBkaXJlY3Rpb25zIHNldCAqLwotc3RhdGljIHZvaWQgc2hfZXRoX3NldF9tdWx0aWNhc3RfbGlzdChzdHJ1Y3QgbmV0X2RldmljZSAqbmRldikKKy8qIFVwZGF0ZSBwcm9taXNjdW91cyBmbGFnIGFuZCBtdWx0aWNhc3QgZmlsdGVyICovCitzdGF0aWMgdm9pZCBzaF9ldGhfc2V0X3J4X21vZGUoc3RydWN0IG5ldF9kZXZpY2UgKm5kZXYpCiB7CiAJc3RydWN0IHNoX2V0aF9wcml2YXRlICptZHAgPSBuZXRkZXZfcHJpdihuZGV2KTsKIAl1MzIgZWNtcl9iaXRzOwpAQCAtMjQ2Miw3ICsyNTM0LDkgQEAKIAkvKiBJbml0aWFsIGNvbmRpdGlvbiBpcyBNQ1QgPSAxLCBQUk0gPSAwLgogCSAqIERlcGVuZGluZyBvbiBuZGV2LT5mbGFncywgc2V0IFBSTSBvciBjbGVhciBNQ1QKIAkgKi8KLQllY21yX2JpdHMgPSAoc2hfZXRoX3JlYWQobmRldiwgRUNNUikgJiB+RUNNUl9QUk0pIHwgRUNNUl9NQ1Q7CisJZWNtcl9iaXRzID0gc2hfZXRoX3JlYWQobmRldiwgRUNNUikgJiB+RUNNUl9QUk07CisJaWYgKG1kcC0+Y2QtPnRzdSkKKwkJZWNtcl9iaXRzIHw9IEVDTVJfTUNUOwogCiAJaWYgKCEobmRldi0+ZmxhZ3MgJiBJRkZfTVVMVElDQVNUKSkgewogCQlzaF9ldGhfdHN1X3B1cmdlX21jYXN0KG5kZXYpOwpAQCAtMjQ5MSw5ICsyNTY1LDYgQEAKIAkJCQl9CiAJCQl9CiAJCX0KLQl9IGVsc2UgewotCQkvKiBOb3JtYWwsIHVuaWNhc3QvYnJvYWRjYXN0LW9ubHkgbW9kZS4gKi8KLQkJZWNtcl9iaXRzID0gKGVjbXJfYml0cyAmIH5FQ01SX1BSTSkgfCBFQ01SX01DVDsKIAl9CiAKIAkvKiB1cGRhdGUgdGhlIGV0aGVybmV0IG1vZGUgKi8KQEAgLTI3MDEsNiArMjc3Miw3IEBACiAJLm5kb19zdG9wCQk9IHNoX2V0aF9jbG9zZSwKIAkubmRvX3N0YXJ0X3htaXQJCT0gc2hfZXRoX3N0YXJ0X3htaXQsCiAJLm5kb19nZXRfc3RhdHMJCT0gc2hfZXRoX2dldF9zdGF0cywKKwkubmRvX3NldF9yeF9tb2RlCT0gc2hfZXRoX3NldF9yeF9tb2RlLAogCS5uZG9fdHhfdGltZW91dAkJPSBzaF9ldGhfdHhfdGltZW91dCwKIAkubmRvX2RvX2lvY3RsCQk9IHNoX2V0aF9kb19pb2N0bCwKIAkubmRvX3ZhbGlkYXRlX2FkZHIJPSBldGhfdmFsaWRhdGVfYWRkciwKQEAgLTI3MTMsNyArMjc4NSw3IEBACiAJLm5kb19zdG9wCQk9IHNoX2V0aF9jbG9zZSwKIAkubmRvX3N0YXJ0X3htaXQJCT0gc2hfZXRoX3N0YXJ0X3htaXQsCiAJLm5kb19nZXRfc3RhdHMJCT0gc2hfZXRoX2dldF9zdGF0cywKLQkubmRvX3NldF9yeF9tb2RlCT0gc2hfZXRoX3NldF9tdWx0aWNhc3RfbGlzdCwKKwkubmRvX3NldF9yeF9tb2RlCT0gc2hfZXRoX3NldF9yeF9tb2RlLAogCS5uZG9fdmxhbl9yeF9hZGRfdmlkCT0gc2hfZXRoX3ZsYW5fcnhfYWRkX3ZpZCwKIAkubmRvX3ZsYW5fcnhfa2lsbF92aWQJPSBzaF9ldGhfdmxhbl9yeF9raWxsX3ZpZCwKIAkubmRvX3R4X3RpbWVvdXQJCT0gc2hfZXRoX3R4X3RpbWVvdXQsCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9yZW5lc2FzL3NoX2V0aC5oIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvcmVuZXNhcy9zaF9ldGguaAppbmRleCA3MWY1ZGUxLi4zMzJkM2MxIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9yZW5lc2FzL3NoX2V0aC5oCisrKyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L3JlbmVzYXMvc2hfZXRoLmgKQEAgLTUxMyw2ICs1MTMsNyBAQAogCXUzMiByeF9idWZfc3o7CQkJLyogQmFzZWQgb24gTVRVK3NsYWNrLiAqLwogCWludCBlZG1hY19lbmRpYW47CiAJc3RydWN0IG5hcGlfc3RydWN0IG5hcGk7CisJYm9vbCBpcnFfZW5hYmxlZDsKIAkvKiBNSUkgdHJhbnNjZWl2ZXIgc2VjdGlvbi4gKi8KIAl1MzIgcGh5X2lkOwkJCS8qIFBIWSBJRCAqLwogCXN0cnVjdCBtaWlfYnVzICptaWlfYnVzOwkvKiBNRElPIGJ1cyBjb250cm9sICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9zYW1zdW5nL3N4Z2JlL3N4Z2JlX21haW4uYyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L3NhbXN1bmcvc3hnYmUvc3hnYmVfbWFpbi5jCmluZGV4IDY5ODQ5NDQuLmIxYTI3MTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L3NhbXN1bmcvc3hnYmUvc3hnYmVfbWFpbi5jCisrKyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L3NhbXN1bmcvc3hnYmUvc3hnYmVfbWFpbi5jCkBAIC00NzQsMTMgKzQ3NCwxOSBAQAogCS8qIGFsbG9jYXRlIG1lbW9yeSBmb3IgUlggc2tidWZmIGFycmF5ICovCiAJcnhfcmluZy0+cnhfc2tidWZmX2RtYSA9IGttYWxsb2NfYXJyYXkocnhfcnNpemUsCiAJCQkJCSAgICAgICBzaXplb2YoZG1hX2FkZHJfdCksIEdGUF9LRVJORUwpOwotCWlmIChyeF9yaW5nLT5yeF9za2J1ZmZfZG1hID09IE5VTEwpCi0JCWdvdG8gZG1hbWVtX2VycjsKKwlpZiAoIXJ4X3JpbmctPnJ4X3NrYnVmZl9kbWEpIHsKKwkJZG1hX2ZyZWVfY29oZXJlbnQocHJpdi0+ZGV2aWNlLAorCQkJCSAgcnhfcnNpemUgKiBzaXplb2Yoc3RydWN0IHN4Z2JlX3J4X25vcm1fZGVzYyksCisJCQkJICByeF9yaW5nLT5kbWFfcngsIHJ4X3JpbmctPmRtYV9yeF9waHkpOworCQlnb3RvIGVycm9yOworCX0KIAogCXJ4X3JpbmctPnJ4X3NrYnVmZiA9IGttYWxsb2NfYXJyYXkocnhfcnNpemUsCiAJCQkJCSAgIHNpemVvZihzdHJ1Y3Qgc2tfYnVmZiAqKSwgR0ZQX0tFUk5FTCk7Ci0JaWYgKHJ4X3JpbmctPnJ4X3NrYnVmZiA9PSBOVUxMKQotCQlnb3RvIHJ4YnVmZl9lcnI7CisJaWYgKCFyeF9yaW5nLT5yeF9za2J1ZmYpIHsKKwkJa2ZyZWUocnhfcmluZy0+cnhfc2tidWZmX2RtYSk7CisJCWdvdG8gZXJyb3I7CisJfQogCiAJLyogaW5pdGlhbGlzZSB0aGUgYnVmZmVycyAqLwogCWZvciAoZGVzY19pbmRleCA9IDA7IGRlc2NfaW5kZXggPCByeF9yc2l6ZTsgZGVzY19pbmRleCsrKSB7CkBAIC01MDIsMTMgKzUwOCw2IEBACiBlcnJfaW5pdF9yeF9idWZmZXJzOgogCXdoaWxlICgtLWRlc2NfaW5kZXggPj0gMCkKIAkJZnJlZV9yeF9yaW5nKHByaXYtPmRldmljZSwgcnhfcmluZywgZGVzY19pbmRleCk7Ci0Ja2ZyZWUocnhfcmluZy0+cnhfc2tidWZmKTsKLXJ4YnVmZl9lcnI6Ci0Ja2ZyZWUocnhfcmluZy0+cnhfc2tidWZmX2RtYSk7Ci1kbWFtZW1fZXJyOgotCWRtYV9mcmVlX2NvaGVyZW50KHByaXYtPmRldmljZSwKLQkJCSAgcnhfcnNpemUgKiBzaXplb2Yoc3RydWN0IHN4Z2JlX3J4X25vcm1fZGVzYyksCi0JCQkgIHJ4X3JpbmctPmRtYV9yeCwgcnhfcmluZy0+ZG1hX3J4X3BoeSk7CiBlcnJvcjoKIAlyZXR1cm4gLUVOT01FTTsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L3NhbXN1bmcvc3hnYmUvc3hnYmVfcGxhdGZvcm0uYyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L3NhbXN1bmcvc3hnYmUvc3hnYmVfcGxhdGZvcm0uYwppbmRleCA4NjY1NjBlLi5iMDJlZWQxIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9zYW1zdW5nL3N4Z2JlL3N4Z2JlX3BsYXRmb3JtLmMKKysrIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvc2Ftc3VuZy9zeGdiZS9zeGdiZV9wbGF0Zm9ybS5jCkBAIC0xMDgsMTAgKzEwOCw2IEBACiAJCX0KIAl9CiAKLQkvKiBHZXQgTUFDIGFkZHJlc3MgaWYgYXZhaWxhYmxlIChEVCkgKi8KLQlpZiAobWFjKQotCQlldGhlcl9hZGRyX2NvcHkocHJpdi0+ZGV2LT5kZXZfYWRkciwgbWFjKTsKLQogCXByaXYgPSBzeGdiZV9kcnZfcHJvYmUoJihwZGV2LT5kZXYpLCBwbGF0X2RhdCwgYWRkcik7CiAJaWYgKCFwcml2KSB7CiAJCXByX2VycigiJXM6IG1haW4gZHJpdmVyIHByb2JlIGZhaWxlZFxuIiwgX19mdW5jX18pOwpAQCAtMTI1LDYgKzEyMSwxMCBAQAogCQlnb3RvIGVycl9kcnZfcmVtb3ZlOwogCX0KIAorCS8qIEdldCBNQUMgYWRkcmVzcyBpZiBhdmFpbGFibGUgKERUKSAqLworCWlmIChtYWMpCisJCWV0aGVyX2FkZHJfY29weShwcml2LT5kZXYtPmRldl9hZGRyLCBtYWMpOworCiAJLyogR2V0IHRoZSBUWC9SWCBJUlEgbnVtYmVycyAqLwogCWZvciAoaSA9IDAsIGNoYW4gPSAxOyBpIDwgU1hHQkVfVFhfUVVFVUVTOyBpKyspIHsKIAkJcHJpdi0+dHhxW2ldLT5pcnFfbm8gPSBpcnFfb2ZfcGFyc2VfYW5kX21hcChub2RlLCBjaGFuKyspOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvc3RtbWFjX21haW4uYyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL3N0bW1hY19tYWluLmMKaW5kZXggOGM2YjdjMS4uY2Y2MmZmNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvc3RtbWFjX21haW4uYworKysgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9zdG1pY3JvL3N0bW1hYy9zdG1tYWNfbWFpbi5jCkBAIC0yNzc4LDYgKzI3NzgsOSBAQAogICogQGFkZHI6IGlvYmFzZSBtZW1vcnkgYWRkcmVzcwogICogRGVzY3JpcHRpb246IHRoaXMgaXMgdGhlIG1haW4gcHJvYmUgZnVuY3Rpb24gdXNlZCB0bwogICogY2FsbCB0aGUgYWxsb2NfZXRoZXJkZXYsIGFsbG9jYXRlIHRoZSBwcml2IHN0cnVjdHVyZS4KKyAqIFJldHVybjoKKyAqIG9uIHN1Y2Nlc3MgdGhlIG5ldyBwcml2YXRlIHN0cnVjdHVyZSBpcyByZXR1cm5lZCwgb3RoZXJ3aXNlIHRoZSBlcnJvcgorICogcG9pbnRlci4KICAqLwogc3RydWN0IHN0bW1hY19wcml2ICpzdG1tYWNfZHZyX3Byb2JlKHN0cnVjdCBkZXZpY2UgKmRldmljZSwKIAkJCQkgICAgIHN0cnVjdCBwbGF0X3N0bW1hY2VuZXRfZGF0YSAqcGxhdF9kYXQsCkBAIC0yNzg5LDcgKzI3OTIsNyBAQAogCiAJbmRldiA9IGFsbG9jX2V0aGVyZGV2KHNpemVvZihzdHJ1Y3Qgc3RtbWFjX3ByaXYpKTsKIAlpZiAoIW5kZXYpCi0JCXJldHVybiBOVUxMOworCQlyZXR1cm4gRVJSX1BUUigtRU5PTUVNKTsKIAogCVNFVF9ORVRERVZfREVWKG5kZXYsIGRldmljZSk7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L3N1bi9zdW52bmV0LmMgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9zdW4vc3Vudm5ldC5jCmluZGV4IGQyODM1YmYuLjM2OTliOTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L3N1bi9zdW52bmV0LmMKKysrIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3VuL3N1bnZuZXQuYwpAQCAtMTExOSw2ICsxMTE5LDcgQEAKIAkJCXNrYl9zaGluZm8obnNrYiktPmdzb19zaXplID0gc2tiX3NoaW5mbyhza2IpLT5nc29fc2l6ZTsKIAkJCXNrYl9zaGluZm8obnNrYiktPmdzb190eXBlID0gc2tiX3NoaW5mbyhza2IpLT5nc29fdHlwZTsKIAkJfQorCQluc2tiLT5xdWV1ZV9tYXBwaW5nID0gc2tiLT5xdWV1ZV9tYXBwaW5nOwogCQlkZXZfa2ZyZWVfc2tiKHNrYik7CiAJCXNrYiA9IG5za2I7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvdGkvY3Bzdy5jIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvdGkvY3Bzdy5jCmluZGV4IDY0ZDFjZWYuLmEzOTEzMWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L3RpL2Nwc3cuYworKysgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC90aS9jcHN3LmMKQEAgLTE2MzQsMTYgKzE2MzQsMjQgQEAKIAkJCQl1bnNpZ25lZCBzaG9ydCB2aWQpCiB7CiAJaW50IHJldDsKLQlpbnQgdW5yZWdfbWNhc3RfbWFzazsKKwlpbnQgdW5yZWdfbWNhc3RfbWFzayA9IDA7CisJdTMyIHBvcnRfbWFzazsKIAotCWlmIChwcml2LT5uZGV2LT5mbGFncyAmIElGRl9BTExNVUxUSSkKLQkJdW5yZWdfbWNhc3RfbWFzayA9IEFMRV9BTExfUE9SVFM7Ci0JZWxzZQotCQl1bnJlZ19tY2FzdF9tYXNrID0gQUxFX1BPUlRfMSB8IEFMRV9QT1JUXzI7CisJaWYgKHByaXYtPmRhdGEuZHVhbF9lbWFjKSB7CisJCXBvcnRfbWFzayA9ICgxIDw8IChwcml2LT5lbWFjX3BvcnQgKyAxKSkgfCBBTEVfUE9SVF9IT1NUOwogCi0JcmV0ID0gY3Bzd19hbGVfYWRkX3ZsYW4ocHJpdi0+YWxlLCB2aWQsCi0JCQkJQUxFX0FMTF9QT1JUUyA8PCBwcml2LT5ob3N0X3BvcnQsCi0JCQkJMCwgQUxFX0FMTF9QT1JUUyA8PCBwcml2LT5ob3N0X3BvcnQsCisJCWlmIChwcml2LT5uZGV2LT5mbGFncyAmIElGRl9BTExNVUxUSSkKKwkJCXVucmVnX21jYXN0X21hc2sgPSBwb3J0X21hc2s7CisJfSBlbHNlIHsKKwkJcG9ydF9tYXNrID0gQUxFX0FMTF9QT1JUUzsKKworCQlpZiAocHJpdi0+bmRldi0+ZmxhZ3MgJiBJRkZfQUxMTVVMVEkpCisJCQl1bnJlZ19tY2FzdF9tYXNrID0gQUxFX0FMTF9QT1JUUzsKKwkJZWxzZQorCQkJdW5yZWdfbWNhc3RfbWFzayA9IEFMRV9QT1JUXzEgfCBBTEVfUE9SVF8yOworCX0KKworCXJldCA9IGNwc3dfYWxlX2FkZF92bGFuKHByaXYtPmFsZSwgdmlkLCBwb3J0X21hc2ssIDAsIHBvcnRfbWFzaywKIAkJCQl1bnJlZ19tY2FzdF9tYXNrIDw8IHByaXYtPmhvc3RfcG9ydCk7CiAJaWYgKHJldCAhPSAwKQogCQlyZXR1cm4gcmV0OwpAQCAtMTY1NCw4ICsxNjYyLDcgQEAKIAkJZ290byBjbGVhbl92aWQ7CiAKIAlyZXQgPSBjcHN3X2FsZV9hZGRfbWNhc3QocHJpdi0+YWxlLCBwcml2LT5uZGV2LT5icm9hZGNhc3QsCi0JCQkJIEFMRV9BTExfUE9SVFMgPDwgcHJpdi0+aG9zdF9wb3J0LAotCQkJCSBBTEVfVkxBTiwgdmlkLCAwKTsKKwkJCQkgcG9ydF9tYXNrLCBBTEVfVkxBTiwgdmlkLCAwKTsKIAlpZiAocmV0ICE9IDApCiAJCWdvdG8gY2xlYW5fdmxhbl91Y2FzdDsKIAlyZXR1cm4gMDsKQEAgLTE2NzYsNiArMTY4MywxOSBAQAogCWlmICh2aWQgPT0gcHJpdi0+ZGF0YS5kZWZhdWx0X3ZsYW4pCiAJCXJldHVybiAwOwogCisJaWYgKHByaXYtPmRhdGEuZHVhbF9lbWFjKSB7CisJCS8qIEluIGR1YWwgRU1BQywgcmVzZXJ2ZWQgVkxBTiBpZCBzaG91bGQgbm90IGJlIHVzZWQgZm9yCisJCSAqIGNyZWF0aW5nIFZMQU4gaW50ZXJmYWNlcyBhcyB0aGlzIGNhbiBicmVhayB0aGUgZHVhbAorCQkgKiBFTUFDIHBvcnQgc2VwYXJhdGlvbgorCQkgKi8KKwkJaW50IGk7CisKKwkJZm9yIChpID0gMDsgaSA8IHByaXYtPmRhdGEuc2xhdmVzOyBpKyspIHsKKwkJCWlmICh2aWQgPT0gcHJpdi0+c2xhdmVzW2ldLnBvcnRfdmxhbikKKwkJCQlyZXR1cm4gLUVJTlZBTDsKKwkJfQorCX0KKwogCWRldl9pbmZvKHByaXYtPmRldiwgIkFkZGluZyB2bGFuaWQgJWQgdG8gdmxhbiBmaWx0ZXJcbiIsIHZpZCk7CiAJcmV0dXJuIGNwc3dfYWRkX3ZsYW5fYWxlX2VudHJ5KHByaXYsIHZpZCk7CiB9CkBAIC0xNjg5LDYgKzE3MDksMTUgQEAKIAlpZiAodmlkID09IHByaXYtPmRhdGEuZGVmYXVsdF92bGFuKQogCQlyZXR1cm4gMDsKIAorCWlmIChwcml2LT5kYXRhLmR1YWxfZW1hYykgeworCQlpbnQgaTsKKworCQlmb3IgKGkgPSAwOyBpIDwgcHJpdi0+ZGF0YS5zbGF2ZXM7IGkrKykgeworCQkJaWYgKHZpZCA9PSBwcml2LT5zbGF2ZXNbaV0ucG9ydF92bGFuKQorCQkJCXJldHVybiAtRUlOVkFMOworCQl9CisJfQorCiAJZGV2X2luZm8ocHJpdi0+ZGV2LCAicmVtb3ZpbmcgdmxhbmlkICVkIGZyb20gdmxhbiBmaWx0ZXJcbiIsIHZpZCk7CiAJcmV0ID0gY3Bzd19hbGVfZGVsX3ZsYW4ocHJpdi0+YWxlLCB2aWQsIDApOwogCWlmIChyZXQgIT0gMCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L3RpL2RhdmluY2lfZW1hYy5jIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvdGkvZGF2aW5jaV9lbWFjLmMKaW5kZXggZWE3MTI1MS4uNWZhZTQzNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvdGkvZGF2aW5jaV9lbWFjLmMKKysrIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvdGkvZGF2aW5jaV9lbWFjLmMKQEAgLTYyLDYgKzYyLDcgQEAKICNpbmNsdWRlIDxsaW51eC9vZi5oPgogI2luY2x1ZGUgPGxpbnV4L29mX2FkZHJlc3MuaD4KICNpbmNsdWRlIDxsaW51eC9vZl9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9vZl9tZGlvLmg+CiAjaW5jbHVkZSA8bGludXgvb2ZfaXJxLmg+CiAjaW5jbHVkZSA8bGludXgvb2ZfbmV0Lmg+CiAKQEAgLTM0Myw5ICszNDQsNyBAQAogCXUzMiBtdWx0aWNhc3RfaGFzaF9jbnRbRU1BQ19OVU1fTVVMVElDQVNUX0JJVFNdOwogCXUzMiByeF9hZGRyX3R5cGU7CiAJY29uc3QgY2hhciAqcGh5X2lkOwotI2lmZGVmIENPTkZJR19PRgogCXN0cnVjdCBkZXZpY2Vfbm9kZSAqcGh5X25vZGU7Ci0jZW5kaWYKIAlzdHJ1Y3QgcGh5X2RldmljZSAqcGh5ZGV2OwogCXNwaW5sb2NrX3QgbG9jazsKIAkvKnBsYXRmb3JtIHNwZWNpZmljIG1lbWJlcnMqLwpAQCAtOTIyLDYgKzkyMSwxNiBAQAogCQlpZiAocHJpdi0+aW50X2Rpc2FibGUpCiAJCQlwcml2LT5pbnRfZGlzYWJsZSgpOwogCisJCS8qIE5PVEU6IFJ4IFRocmVzaG9sZCBhbmQgTWlzYyBpbnRlcnJ1cHRzIGFyZSBub3QgZW5hYmxlZCAqLworCisJCS8qIGFjayByeGVuIG9ubHkgdGhlbiBhIG5ldyBwdWxzZSB3aWxsIGJlIGdlbmVyYXRlZCAqLworCQllbWFjX3dyaXRlKEVNQUNfRE02NDZYX01BQ0VPSVZFQ1RPUiwKKwkJCUVNQUNfRE02NDZYX01BQ19FT0lfQzBfUlhFTik7CisKKwkJLyogYWNrIHR4ZW4tIG9ubHkgdGhlbiBhIG5ldyBwdWxzZSB3aWxsIGJlIGdlbmVyYXRlZCAqLworCQllbWFjX3dyaXRlKEVNQUNfRE02NDZYX01BQ0VPSVZFQ1RPUiwKKwkJCUVNQUNfRE02NDZYX01BQ19FT0lfQzBfVFhFTik7CisKIAkJbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwogCiAJfSBlbHNlIHsKQEAgLTk1MSwxNSArOTYwLDYgQEAKIAkJICogcmVnaXN0ZXIgKi8KIAogCQkvKiBOT1RFOiBSeCBUaHJlc2hvbGQgYW5kIE1pc2MgaW50ZXJydXB0cyBhcmUgbm90IGVuYWJsZWQgKi8KLQotCQkvKiBhY2sgcnhlbiBvbmx5IHRoZW4gYSBuZXcgcHVsc2Ugd2lsbCBiZSBnZW5lcmF0ZWQgKi8KLQkJZW1hY193cml0ZShFTUFDX0RNNjQ2WF9NQUNFT0lWRUNUT1IsCi0JCQlFTUFDX0RNNjQ2WF9NQUNfRU9JX0MwX1JYRU4pOwotCi0JCS8qIGFjayB0eGVuLSBvbmx5IHRoZW4gYSBuZXcgcHVsc2Ugd2lsbCBiZSBnZW5lcmF0ZWQgKi8KLQkJZW1hY193cml0ZShFTUFDX0RNNjQ2WF9NQUNFT0lWRUNUT1IsCi0JCQlFTUFDX0RNNjQ2WF9NQUNfRU9JX0MwX1RYRU4pOwotCiAJfSBlbHNlIHsKIAkJLyogU2V0IERNNjQ0eCBjb250cm9sIHJlZ2lzdGVycyBmb3IgaW50ZXJydXB0IGNvbnRyb2wgKi8KIAkJZW1hY19jdHJsX3dyaXRlKEVNQUNfQ1RSTF9FV0NUTCwgMHgxKTsKQEAgLTE1MzcsNyArMTUzNywxMyBAQAogCWludCBpID0gMDsKIAlzdHJ1Y3QgZW1hY19wcml2ICpwcml2ID0gbmV0ZGV2X3ByaXYobmRldik7CiAKLQlwbV9ydW50aW1lX2dldCgmcHJpdi0+cGRldi0+ZGV2KTsKKwlyZXQgPSBwbV9ydW50aW1lX2dldF9zeW5jKCZwcml2LT5wZGV2LT5kZXYpOworCWlmIChyZXQgPCAwKSB7CisJCXBtX3J1bnRpbWVfcHV0X25vaWRsZSgmcHJpdi0+cGRldi0+ZGV2KTsKKwkJZGV2X2VycigmcHJpdi0+cGRldi0+ZGV2LCAiJXM6IGZhaWxlZCB0byBnZXRfc3luYyglZClcbiIsCisJCQlfX2Z1bmNfXywgcmV0KTsKKwkJcmV0dXJuIHJldDsKKwl9CiAKIAluZXRpZl9jYXJyaWVyX29mZihuZGV2KTsKIAlmb3IgKGNudCA9IDA7IGNudCA8IEVUSF9BTEVOOyBjbnQrKykKQEAgLTE1OTYsOCArMTYwMiwyMCBAQAogCWNwZG1hX2N0bHJfc3RhcnQocHJpdi0+ZG1hKTsKIAogCXByaXYtPnBoeWRldiA9IE5VTEw7CisKKwlpZiAocHJpdi0+cGh5X25vZGUpIHsKKwkJcHJpdi0+cGh5ZGV2ID0gb2ZfcGh5X2Nvbm5lY3QobmRldiwgcHJpdi0+cGh5X25vZGUsCisJCQkJCSAgICAgICZlbWFjX2FkanVzdF9saW5rLCAwLCAwKTsKKwkJaWYgKCFwcml2LT5waHlkZXYpIHsKKwkJCWRldl9lcnIoZW1hY19kZXYsICJjb3VsZCBub3QgY29ubmVjdCB0byBwaHkgJXNcbiIsCisJCQkJcHJpdi0+cGh5X25vZGUtPmZ1bGxfbmFtZSk7CisJCQlyZXQgPSAtRU5PREVWOworCQkJZ290byBlcnI7CisJCX0KKwl9CisKIAkvKiB1c2UgdGhlIGZpcnN0IHBoeSBvbiB0aGUgYnVzIGlmIHBkYXRhIGRpZCBub3QgZ2l2ZSB1cyBhIHBoeSBpZCAqLwotCWlmICghcHJpdi0+cGh5X2lkKSB7CisJaWYgKCFwcml2LT5waHlkZXYgJiYgIXByaXYtPnBoeV9pZCkgewogCQlzdHJ1Y3QgZGV2aWNlICpwaHk7CiAKIAkJcGh5ID0gYnVzX2ZpbmRfZGV2aWNlKCZtZGlvX2J1c190eXBlLCBOVUxMLCBOVUxMLApAQCAtMTYwNiw3ICsxNjI0LDcgQEAKIAkJCXByaXYtPnBoeV9pZCA9IGRldl9uYW1lKHBoeSk7CiAJfQogCi0JaWYgKHByaXYtPnBoeV9pZCAmJiAqcHJpdi0+cGh5X2lkKSB7CisJaWYgKCFwcml2LT5waHlkZXYgJiYgcHJpdi0+cGh5X2lkICYmICpwcml2LT5waHlfaWQpIHsKIAkJcHJpdi0+cGh5ZGV2ID0gcGh5X2Nvbm5lY3QobmRldiwgcHJpdi0+cGh5X2lkLAogCQkJCQkgICAmZW1hY19hZGp1c3RfbGluaywKIAkJCQkJICAgUEhZX0lOVEVSRkFDRV9NT0RFX01JSSk7CkBAIC0xNjI3LDcgKzE2NDUsOSBAQAogCQkJIihtaWlfYnVzOnBoeV9hZGRyPSVzLCBpZD0leClcbiIsCiAJCQlwcml2LT5waHlkZXYtPmRydi0+bmFtZSwgZGV2X25hbWUoJnByaXYtPnBoeWRldi0+ZGV2KSwKIAkJCXByaXYtPnBoeWRldi0+cGh5X2lkKTsKLQl9IGVsc2UgeworCX0KKworCWlmICghcHJpdi0+cGh5ZGV2KSB7CiAJCS8qIE5vIFBIWSAsIGZpeCB0aGUgbGluaywgc3BlZWQgYW5kIGR1cGxleCBzZXR0aW5ncyAqLwogCQlkZXZfbm90aWNlKGVtYWNfZGV2LCAibm8gcGh5LCBkZWZhdWx0aW5nIHRvIDEwMC9mdWxsXG4iKTsKIAkJcHJpdi0+bGluayA9IDE7CkBAIC0xNzI0LDYgKzE3NDQsMTUgQEAKIAlzdHJ1Y3QgZW1hY19wcml2ICpwcml2ID0gbmV0ZGV2X3ByaXYobmRldik7CiAJdTMyIG1hY19jb250cm9sOwogCXUzMiBzdGF0c19jbGVhcl9tYXNrOworCWludCBlcnI7CisKKwllcnIgPSBwbV9ydW50aW1lX2dldF9zeW5jKCZwcml2LT5wZGV2LT5kZXYpOworCWlmIChlcnIgPCAwKSB7CisJCXBtX3J1bnRpbWVfcHV0X25vaWRsZSgmcHJpdi0+cGRldi0+ZGV2KTsKKwkJZGV2X2VycigmcHJpdi0+cGRldi0+ZGV2LCAiJXM6IGZhaWxlZCB0byBnZXRfc3luYyglZClcbiIsCisJCQlfX2Z1bmNfXywgZXJyKTsKKwkJcmV0dXJuICZuZGV2LT5zdGF0czsKKwl9CiAKIAkvKiB1cGRhdGUgZW1hYyBoYXJkd2FyZSBzdGF0cyBhbmQgcmVzZXQgdGhlIHJlZ2lzdGVycyovCiAKQEAgLTE3NjYsNiArMTc5NSw4IEBACiAJbmRldi0+c3RhdHMudHhfZmlmb19lcnJvcnMgKz0gZW1hY19yZWFkKEVNQUNfVFhVTkRFUlJVTik7CiAJZW1hY193cml0ZShFTUFDX1RYVU5ERVJSVU4sIHN0YXRzX2NsZWFyX21hc2spOwogCisJcG1fcnVudGltZV9wdXQoJnByaXYtPnBkZXYtPmRldik7CisKIAlyZXR1cm4gJm5kZXYtPnN0YXRzOwogfQogCkBAIC0xODU5LDcgKzE4OTAsNyBAQAogc3RhdGljIGludCBkYXZpbmNpX2VtYWNfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIHsKIAlpbnQgcmMgPSAwOwotCXN0cnVjdCByZXNvdXJjZSAqcmVzOworCXN0cnVjdCByZXNvdXJjZSAqcmVzLCAqcmVzX2N0cmw7CiAJc3RydWN0IG5ldF9kZXZpY2UgKm5kZXY7CiAJc3RydWN0IGVtYWNfcHJpdiAqcHJpdjsKIAl1bnNpZ25lZCBsb25nIGh3X3JhbV9hZGRyOwpAQCAtMTg3Niw2ICsxOTA3LDcgQEAKIAkJcmV0dXJuIC1FQlVTWTsKIAl9CiAJZW1hY19idXNfZnJlcXVlbmN5ID0gY2xrX2dldF9yYXRlKGVtYWNfY2xrKTsKKwlkZXZtX2Nsa19wdXQoJnBkZXYtPmRldiwgZW1hY19jbGspOwogCiAJLyogVE9ETzogUHJvYmUgUEhZIGhlcmUgaWYgcG9zc2libGUgKi8KIApAQCAtMTkxNywxMSArMTk0OSwyMCBAQAogCQlyYyA9IFBUUl9FUlIocHJpdi0+cmVtYXBfYWRkcik7CiAJCWdvdG8gbm9fcGRhdGE7CiAJfQorCisJcmVzX2N0cmwgPSBwbGF0Zm9ybV9nZXRfcmVzb3VyY2UocGRldiwgSU9SRVNPVVJDRV9NRU0sIDEpOworCWlmIChyZXNfY3RybCkgeworCQlwcml2LT5jdHJsX2Jhc2UgPQorCQkJZGV2bV9pb3JlbWFwX3Jlc291cmNlKCZwZGV2LT5kZXYsIHJlc19jdHJsKTsKKwkJaWYgKElTX0VSUihwcml2LT5jdHJsX2Jhc2UpKQorCQkJZ290byBub19wZGF0YTsKKwl9IGVsc2UgeworCQlwcml2LT5jdHJsX2Jhc2UgPSBwcml2LT5yZW1hcF9hZGRyICsgcGRhdGEtPmN0cmxfbW9kX3JlZ19vZmZzZXQ7CisJfQorCiAJcHJpdi0+ZW1hY19iYXNlID0gcHJpdi0+cmVtYXBfYWRkciArIHBkYXRhLT5jdHJsX3JlZ19vZmZzZXQ7CiAJbmRldi0+YmFzZV9hZGRyID0gKHVuc2lnbmVkIGxvbmcpcHJpdi0+cmVtYXBfYWRkcjsKIAotCXByaXYtPmN0cmxfYmFzZSA9IHByaXYtPnJlbWFwX2FkZHIgKyBwZGF0YS0+Y3RybF9tb2RfcmVnX29mZnNldDsKLQogCWh3X3JhbV9hZGRyID0gcGRhdGEtPmh3X3JhbV9hZGRyOwogCWlmICghaHdfcmFtX2FkZHIpCiAJCWh3X3JhbV9hZGRyID0gKHUzMiBfX2ZvcmNlKXJlcy0+c3RhcnQgKyBwZGF0YS0+Y3RybF9yYW1fb2Zmc2V0OwpAQCAtMTk4MCwxMiArMjAyMSwyMiBAQAogCW5kZXYtPmV0aHRvb2xfb3BzID0gJmV0aHRvb2xfb3BzOwogCW5ldGlmX25hcGlfYWRkKG5kZXYsICZwcml2LT5uYXBpLCBlbWFjX3BvbGwsIEVNQUNfUE9MTF9XRUlHSFQpOwogCisJcG1fcnVudGltZV9lbmFibGUoJnBkZXYtPmRldik7CisJcmMgPSBwbV9ydW50aW1lX2dldF9zeW5jKCZwZGV2LT5kZXYpOworCWlmIChyYyA8IDApIHsKKwkJcG1fcnVudGltZV9wdXRfbm9pZGxlKCZwZGV2LT5kZXYpOworCQlkZXZfZXJyKCZwZGV2LT5kZXYsICIlczogZmFpbGVkIHRvIGdldF9zeW5jKCVkKVxuIiwKKwkJCV9fZnVuY19fLCByYyk7CisJCWdvdG8gbm9fY3BkbWFfY2hhbjsKKwl9CisKIAkvKiByZWdpc3RlciB0aGUgbmV0d29yayBkZXZpY2UgKi8KIAlTRVRfTkVUREVWX0RFVihuZGV2LCAmcGRldi0+ZGV2KTsKIAlyYyA9IHJlZ2lzdGVyX25ldGRldihuZGV2KTsKIAlpZiAocmMpIHsKIAkJZGV2X2VycigmcGRldi0+ZGV2LCAiZXJyb3IgaW4gcmVnaXN0ZXJfbmV0ZGV2XG4iKTsKIAkJcmMgPSAtRU5PREVWOworCQlwbV9ydW50aW1lX3B1dCgmcGRldi0+ZGV2KTsKIAkJZ290byBub19jcGRtYV9jaGFuOwogCX0KIApAQCAtMTk5NSw5ICsyMDQ2LDcgQEAKIAkJCSAgICIocmVnczogJXAsIGlycTogJWQpXG4iLAogCQkJICAgKHZvaWQgKilwcml2LT5lbWFjX2Jhc2VfcGh5cywgbmRldi0+aXJxKTsKIAl9Ci0KLQlwbV9ydW50aW1lX2VuYWJsZSgmcGRldi0+ZGV2KTsKLQlwbV9ydW50aW1lX3Jlc3VtZSgmcGRldi0+ZGV2KTsKKwlwbV9ydW50aW1lX3B1dCgmcGRldi0+ZGV2KTsKIAogCXJldHVybiAwOwogCkBAIC0yMDcxLDkgKzIxMjAsMTQgQEAKIAkuaHdfcmFtX2FkZHIJCT0gMHgwMWUyMDAwMCwKIH07CiAKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZW1hY19wbGF0Zm9ybV9kYXRhIGRtODE2X2VtYWNfZGF0YSA9IHsKKwkudmVyc2lvbgkJPSBFTUFDX1ZFUlNJT05fMiwKK307CisKIHN0YXRpYyBjb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkIGRhdmluY2lfZW1hY19vZl9tYXRjaFtdID0gewogCXsuY29tcGF0aWJsZSA9ICJ0aSxkYXZpbmNpLWRtNjQ2Ny1lbWFjIiwgfSwKIAl7LmNvbXBhdGlibGUgPSAidGksYW0zNTE3LWVtYWMiLCAuZGF0YSA9ICZhbTM1MTdfZW1hY19kYXRhLCB9LAorCXsuY29tcGF0aWJsZSA9ICJ0aSxkbTgxNi1lbWFjIiwgLmRhdGEgPSAmZG04MTZfZW1hY19kYXRhLCB9LAogCXt9LAogfTsKIE1PRFVMRV9ERVZJQ0VfVEFCTEUob2YsIGRhdmluY2lfZW1hY19vZl9tYXRjaCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9oeXBlcnYvbmV0dnNjLmMgYi9kcml2ZXJzL25ldC9oeXBlcnYvbmV0dnNjLmMKaW5kZXggOWY0OWMwMS4uN2NkNGViMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvaHlwZXJ2L25ldHZzYy5jCisrKyBiL2RyaXZlcnMvbmV0L2h5cGVydi9uZXR2c2MuYwpAQCAtNzE2LDcgKzcxNiw3IEBACiAJdTY0IHJlcV9pZDsKIAl1bnNpZ25lZCBpbnQgc2VjdGlvbl9pbmRleCA9IE5FVFZTQ19JTlZBTElEX0lOREVYOwogCXUzMiBtc2dfc2l6ZSA9IDA7Ci0Jc3RydWN0IHNrX2J1ZmYgKnNrYjsKKwlzdHJ1Y3Qgc2tfYnVmZiAqc2tiID0gTlVMTDsKIAl1MTYgcV9pZHggPSBwYWNrZXQtPnFfaWR4OwogCiAKQEAgLTc0Myw4ICs3NDMsNiBAQAogCQkJCQkJCSAgIHBhY2tldCk7CiAJCQlza2IgPSAoc3RydWN0IHNrX2J1ZmYgKikKIAkJCSAgICAgICh1bnNpZ25lZCBsb25nKXBhY2tldC0+c2VuZF9jb21wbGV0aW9uX3RpZDsKLQkJCWlmIChza2IpCi0JCQkJZGV2X2tmcmVlX3NrYl9hbnkoc2tiKTsKIAkJCXBhY2tldC0+cGFnZV9idWZfY250ID0gMDsKIAkJfQogCX0KQEAgLTgxMCw2ICs4MDgsMTMgQEAKIAkJCSAgIHBhY2tldCwgcmV0KTsKIAl9CiAKKwlpZiAocmV0ICE9IDApIHsKKwkJaWYgKHNlY3Rpb25faW5kZXggIT0gTkVUVlNDX0lOVkFMSURfSU5ERVgpCisJCQluZXR2c2NfZnJlZV9zZW5kX3Nsb3QobmV0X2RldmljZSwgc2VjdGlvbl9pbmRleCk7CisJfSBlbHNlIGlmIChza2IpIHsKKwkJZGV2X2tmcmVlX3NrYl9hbnkoc2tiKTsKKwl9CisKIAlyZXR1cm4gcmV0OwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9pcHZsYW4vaXB2bGFuX2NvcmUuYyBiL2RyaXZlcnMvbmV0L2lwdmxhbi9pcHZsYW5fY29yZS5jCmluZGV4IGExNGQ4NzcuLjJlMTk1MjggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2lwdmxhbi9pcHZsYW5fY29yZS5jCisrKyBiL2RyaXZlcnMvbmV0L2lwdmxhbi9pcHZsYW5fY29yZS5jCkBAIC0zNzcsOSArMzc3LDExIEBACiAJfTsKIAogCWRzdCA9IGlwNl9yb3V0ZV9vdXRwdXQoZGV2X25ldChkZXYpLCBOVUxMLCAmZmw2KTsKLQlpZiAoSVNfRVJSKGRzdCkpCisJaWYgKGRzdC0+ZXJyb3IpIHsKKwkJcmV0ID0gZHN0LT5lcnJvcjsKKwkJZHN0X3JlbGVhc2UoZHN0KTsKIAkJZ290byBlcnI7Ci0KKwl9CiAJc2tiX2RzdF9kcm9wKHNrYik7CiAJc2tiX2RzdF9zZXQoc2tiLCBkc3QpOwogCWVyciA9IGlwNl9sb2NhbF9vdXQoc2tiKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L21hY3Z0YXAuYyBiL2RyaXZlcnMvbmV0L21hY3Z0YXAuYwppbmRleCA3ZGYyMjE3Li45MTlmNGZjIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9tYWN2dGFwLmMKKysrIGIvZHJpdmVycy9uZXQvbWFjdnRhcC5jCkBAIC0xNyw3ICsxNyw2IEBACiAjaW5jbHVkZSA8bGludXgvZnMuaD4KICNpbmNsdWRlIDxsaW51eC91aW8uaD4KIAotI2luY2x1ZGUgPG5ldC9pcHY2Lmg+CiAjaW5jbHVkZSA8bmV0L25ldF9uYW1lc3BhY2UuaD4KICNpbmNsdWRlIDxuZXQvcnRuZXRsaW5rLmg+CiAjaW5jbHVkZSA8bmV0L3NvY2suaD4KQEAgLTgxLDcgKzgwLDcgQEAKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgcHJvdG9fb3BzIG1hY3Z0YXBfc29ja2V0X29wczsKIAogI2RlZmluZSBUVU5fT0ZGTE9BRFMgKE5FVElGX0ZfSFdfQ1NVTSB8IE5FVElGX0ZfVFNPX0VDTiB8IE5FVElGX0ZfVFNPIHwgXAotCQkgICAgICBORVRJRl9GX1RTTzYpCisJCSAgICAgIE5FVElGX0ZfVFNPNiB8IE5FVElGX0ZfVUZPKQogI2RlZmluZSBSWF9PRkZMT0FEUyAoTkVUSUZfRl9HUk8gfCBORVRJRl9GX0xSTykKICNkZWZpbmUgVEFQX0ZFQVRVUkVTIChORVRJRl9GX0dTTyB8IE5FVElGX0ZfU0cpCiAKQEAgLTU4NiwxMSArNTg1LDcgQEAKIAkJCWdzb190eXBlID0gU0tCX0dTT19UQ1BWNjsKIAkJCWJyZWFrOwogCQljYXNlIFZJUlRJT19ORVRfSERSX0dTT19VRFA6Ci0JCQlwcl93YXJuX29uY2UoIm1hY3Z0YXA6ICVzOiB1c2luZyBkaXNhYmxlZCBVRk8gZmVhdHVyZTsgcGxlYXNlIGZpeCB0aGlzIHByb2dyYW1cbiIsCi0JCQkJICAgICBjdXJyZW50LT5jb21tKTsKIAkJCWdzb190eXBlID0gU0tCX0dTT19VRFA7Ci0JCQlpZiAoc2tiLT5wcm90b2NvbCA9PSBodG9ucyhFVEhfUF9JUFY2KSkKLQkJCQlpcHY2X3Byb3h5X3NlbGVjdF9pZGVudChza2IpOwogCQkJYnJlYWs7CiAJCWRlZmF1bHQ6CiAJCQlyZXR1cm4gLUVJTlZBTDsKQEAgLTYzNiw2ICs2MzEsOCBAQAogCQkJdm5ldF9oZHItPmdzb190eXBlID0gVklSVElPX05FVF9IRFJfR1NPX1RDUFY0OwogCQllbHNlIGlmIChzaW5mby0+Z3NvX3R5cGUgJiBTS0JfR1NPX1RDUFY2KQogCQkJdm5ldF9oZHItPmdzb190eXBlID0gVklSVElPX05FVF9IRFJfR1NPX1RDUFY2OworCQllbHNlIGlmIChzaW5mby0+Z3NvX3R5cGUgJiBTS0JfR1NPX1VEUCkKKwkJCXZuZXRfaGRyLT5nc29fdHlwZSA9IFZJUlRJT19ORVRfSERSX0dTT19VRFA7CiAJCWVsc2UKIAkJCUJVRygpOwogCQlpZiAoc2luZm8tPmdzb190eXBlICYgU0tCX0dTT19UQ1BfRUNOKQpAQCAtOTY1LDYgKzk2Miw5IEBACiAJCQlpZiAoYXJnICYgVFVOX0ZfVFNPNikKIAkJCQlmZWF0dXJlX21hc2sgfD0gTkVUSUZfRl9UU082OwogCQl9CisKKwkJaWYgKGFyZyAmIFRVTl9GX1VGTykKKwkJCWZlYXR1cmVfbWFzayB8PSBORVRJRl9GX1VGTzsKIAl9CiAKIAkvKiB0dW4vdGFwIGRyaXZlciBpbnZlcnRzIHRoZSB1c2FnZSBmb3IgVFNPIG9mZmxvYWRzLCB3aGVyZQpAQCAtOTc1LDcgKzk3NSw3IEBACiAJICogV2hlbiB1c2VyIHNwYWNlIHR1cm5zIG9mZiBUU08sIHdlIHR1cm4gb2ZmIEdTTy9MUk8gc28gdGhhdAogCSAqIHVzZXItc3BhY2Ugd2lsbCBub3QgcmVjZWl2ZSBUU08gZnJhbWVzLgogCSAqLwotCWlmIChmZWF0dXJlX21hc2sgJiAoTkVUSUZfRl9UU08gfCBORVRJRl9GX1RTTzYpKQorCWlmIChmZWF0dXJlX21hc2sgJiAoTkVUSUZfRl9UU08gfCBORVRJRl9GX1RTTzYgfCBORVRJRl9GX1VGTykpCiAJCWZlYXR1cmVzIHw9IFJYX09GRkxPQURTOwogCWVsc2UKIAkJZmVhdHVyZXMgJj0gflJYX09GRkxPQURTOwpAQCAtMTA5MCw3ICsxMDkwLDcgQEAKIAljYXNlIFRVTlNFVE9GRkxPQUQ6CiAJCS8qIGxldCB0aGUgdXNlciBjaGVjayBmb3IgZnV0dXJlIGZsYWdzICovCiAJCWlmIChhcmcgJiB+KFRVTl9GX0NTVU0gfCBUVU5fRl9UU080IHwgVFVOX0ZfVFNPNiB8Ci0JCQkgICAgVFVOX0ZfVFNPX0VDTikpCisJCQkgICAgVFVOX0ZfVFNPX0VDTiB8IFRVTl9GX1VGTykpCiAJCQlyZXR1cm4gLUVJTlZBTDsKIAogCQlydG5sX2xvY2soKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3BwcC9wcHBfZGVmbGF0ZS5jIGIvZHJpdmVycy9uZXQvcHBwL3BwcF9kZWZsYXRlLmMKaW5kZXggNjAyYzYyNS4uYjVlZGM3ZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvcHBwL3BwcF9kZWZsYXRlLmMKKysrIGIvZHJpdmVycy9uZXQvcHBwL3BwcF9kZWZsYXRlLmMKQEAgLTI0Niw3ICsyNDYsNyBAQAogCS8qCiAJICogU2VlIGlmIHdlIG1hbmFnZWQgdG8gcmVkdWNlIHRoZSBzaXplIG9mIHRoZSBwYWNrZXQuCiAJICovCi0JaWYgKG9sZW4gPCBpc2l6ZSkgeworCWlmIChvbGVuIDwgaXNpemUgJiYgb2xlbiA8PSBvc2l6ZSkgewogCQlzdGF0ZS0+c3RhdHMuY29tcF9ieXRlcyArPSBvbGVuOwogCQlzdGF0ZS0+c3RhdHMuY29tcF9wYWNrZXRzKys7CiAJfSBlbHNlIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3R1bi5jIGIvZHJpdmVycy9uZXQvdHVuLmMKaW5kZXggOGM4ZGMxNi4uMTBmOWU0MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvdHVuLmMKKysrIGIvZHJpdmVycy9uZXQvdHVuLmMKQEAgLTY1LDcgKzY1LDYgQEAKICNpbmNsdWRlIDxsaW51eC9uc3Byb3h5Lmg+CiAjaW5jbHVkZSA8bGludXgvdmlydGlvX25ldC5oPgogI2luY2x1ZGUgPGxpbnV4L3JjdXBkYXRlLmg+Ci0jaW5jbHVkZSA8bmV0L2lwdjYuaD4KICNpbmNsdWRlIDxuZXQvbmV0X25hbWVzcGFjZS5oPgogI2luY2x1ZGUgPG5ldC9uZXRucy9nZW5lcmljLmg+CiAjaW5jbHVkZSA8bmV0L3J0bmV0bGluay5oPgpAQCAtMTg3LDcgKzE4Niw3IEBACiAJc3RydWN0IG5ldF9kZXZpY2UJKmRldjsKIAluZXRkZXZfZmVhdHVyZXNfdAlzZXRfZmVhdHVyZXM7CiAjZGVmaW5lIFRVTl9VU0VSX0ZFQVRVUkVTIChORVRJRl9GX0hXX0NTVU18TkVUSUZfRl9UU09fRUNOfE5FVElGX0ZfVFNPfCBcCi0JCQkgIE5FVElGX0ZfVFNPNikKKwkJCSAgTkVUSUZfRl9UU082fE5FVElGX0ZfVUZPKQogCiAJaW50CQkJdm5ldF9oZHJfc3o7CiAJaW50CQkJc25kYnVmOwpAQCAtMTE2Nyw4ICsxMTY2LDYgQEAKIAkJYnJlYWs7CiAJfQogCi0Jc2tiX3Jlc2V0X25ldHdvcmtfaGVhZGVyKHNrYik7Ci0KIAlpZiAoZ3NvLmdzb190eXBlICE9IFZJUlRJT19ORVRfSERSX0dTT19OT05FKSB7CiAJCXByX2RlYnVnKCJHU08hXG4iKTsKIAkJc3dpdGNoIChnc28uZ3NvX3R5cGUgJiB+VklSVElPX05FVF9IRFJfR1NPX0VDTikgewpAQCAtMTE3OSwyMCArMTE3Niw4IEBACiAJCQlza2Jfc2hpbmZvKHNrYiktPmdzb190eXBlID0gU0tCX0dTT19UQ1BWNjsKIAkJCWJyZWFrOwogCQljYXNlIFZJUlRJT19ORVRfSERSX0dTT19VRFA6Ci0JCXsKLQkJCXN0YXRpYyBib29sIHdhcm5lZDsKLQotCQkJaWYgKCF3YXJuZWQpIHsKLQkJCQl3YXJuZWQgPSB0cnVlOwotCQkJCW5ldGRldl93YXJuKHR1bi0+ZGV2LAotCQkJCQkgICAgIiVzOiB1c2luZyBkaXNhYmxlZCBVRk8gZmVhdHVyZTsgcGxlYXNlIGZpeCB0aGlzIHByb2dyYW1cbiIsCi0JCQkJCSAgICBjdXJyZW50LT5jb21tKTsKLQkJCX0KIAkJCXNrYl9zaGluZm8oc2tiKS0+Z3NvX3R5cGUgPSBTS0JfR1NPX1VEUDsKLQkJCWlmIChza2ItPnByb3RvY29sID09IGh0b25zKEVUSF9QX0lQVjYpKQotCQkJCWlwdjZfcHJveHlfc2VsZWN0X2lkZW50KHNrYik7CiAJCQlicmVhazsKLQkJfQogCQlkZWZhdWx0OgogCQkJdHVuLT5kZXYtPnN0YXRzLnJ4X2ZyYW1lX2Vycm9ycysrOwogCQkJa2ZyZWVfc2tiKHNrYik7CkBAIC0xMjIxLDYgKzEyMDYsNyBAQAogCQlza2Jfc2hpbmZvKHNrYiktPnR4X2ZsYWdzIHw9IFNLQlRYX1NIQVJFRF9GUkFHOwogCX0KIAorCXNrYl9yZXNldF9uZXR3b3JrX2hlYWRlcihza2IpOwogCXNrYl9wcm9iZV90cmFuc3BvcnRfaGVhZGVyKHNrYiwgMCk7CiAKIAlyeGhhc2ggPSBza2JfZ2V0X2hhc2goc2tiKTsKQEAgLTEyOTgsNiArMTI4NCw4IEBACiAJCQkJZ3NvLmdzb190eXBlID0gVklSVElPX05FVF9IRFJfR1NPX1RDUFY0OwogCQkJZWxzZSBpZiAoc2luZm8tPmdzb190eXBlICYgU0tCX0dTT19UQ1BWNikKIAkJCQlnc28uZ3NvX3R5cGUgPSBWSVJUSU9fTkVUX0hEUl9HU09fVENQVjY7CisJCQllbHNlIGlmIChzaW5mby0+Z3NvX3R5cGUgJiBTS0JfR1NPX1VEUCkKKwkJCQlnc28uZ3NvX3R5cGUgPSBWSVJUSU9fTkVUX0hEUl9HU09fVURQOwogCQkJZWxzZSB7CiAJCQkJcHJfZXJyKCJ1bmV4cGVjdGVkIEdTTyB0eXBlOiAiCiAJCQkJICAgICAgICIweCV4LCBnc29fc2l6ZSAlZCwgaGRyX2xlbiAlZFxuIiwKQEAgLTE3NDYsNiArMTczNCwxMSBAQAogCQkJCWZlYXR1cmVzIHw9IE5FVElGX0ZfVFNPNjsKIAkJCWFyZyAmPSB+KFRVTl9GX1RTTzR8VFVOX0ZfVFNPNik7CiAJCX0KKworCQlpZiAoYXJnICYgVFVOX0ZfVUZPKSB7CisJCQlmZWF0dXJlcyB8PSBORVRJRl9GX1VGTzsKKwkJCWFyZyAmPSB+VFVOX0ZfVUZPOworCQl9CiAJfQogCiAJLyogVGhpcyBnaXZlcyB0aGUgdXNlciBhIHdheSB0byB0ZXN0IGZvciBuZXcgZmVhdHVyZXMgaW4gZnV0dXJlIGJ5CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC91c2IvcjgxNTIuYyBiL2RyaXZlcnMvbmV0L3VzYi9yODE1Mi5jCmluZGV4IDU3ZWMyM2UuLmJmNDA1ZjEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3VzYi9yODE1Mi5jCisrKyBiL2RyaXZlcnMvbmV0L3VzYi9yODE1Mi5jCkBAIC04MzMsOSArODMzLDYgQEAKIAkJaW5kZXggJj0gfjM7CiAJfQogCi0JZ2VuZXJpY19vY3BfcmVhZCh0cCwgaW5kZXgsIHNpemVvZih0bXApLCAmdG1wLCB0eXBlKTsKLQotCWRhdGEgfD0gX19sZTMyX3RvX2NwdSh0bXApICYgfm1hc2s7CiAJdG1wID0gX19jcHVfdG9fbGUzMihkYXRhKTsKIAogCWdlbmVyaWNfb2NwX3dyaXRlKHRwLCBpbmRleCwgYnllbiwgc2l6ZW9mKHRtcCksICZ0bXAsIHR5cGUpOwpAQCAtODc0LDkgKzg3MSw2IEBACiAJCWluZGV4ICY9IH4zOwogCX0KIAotCWdlbmVyaWNfb2NwX3JlYWQodHAsIGluZGV4LCBzaXplb2YodG1wKSwgJnRtcCwgdHlwZSk7Ci0KLQlkYXRhIHw9IF9fbGUzMl90b19jcHUodG1wKSAmIH5tYXNrOwogCXRtcCA9IF9fY3B1X3RvX2xlMzIoZGF0YSk7CiAKIAlnZW5lcmljX29jcF93cml0ZSh0cCwgaW5kZXgsIGJ5ZW4sIHNpemVvZih0bXApLCAmdG1wLCB0eXBlKTsKQEAgLTkyNiwxMiArOTIwLDYgQEAKIAlvY3BfcmVnX3dyaXRlKHRwLCBPQ1BfU1JBTV9EQVRBLCBkYXRhKTsKIH0KIAotc3RhdGljIHUxNiBzcmFtX3JlYWQoc3RydWN0IHI4MTUyICp0cCwgdTE2IGFkZHIpCi17Ci0Jb2NwX3JlZ193cml0ZSh0cCwgT0NQX1NSQU1fQUREUiwgYWRkcik7Ci0JcmV0dXJuIG9jcF9yZWdfcmVhZCh0cCwgT0NQX1NSQU1fREFUQSk7Ci19Ci0KIHN0YXRpYyBpbnQgcmVhZF9taWlfd29yZChzdHJ1Y3QgbmV0X2RldmljZSAqbmV0ZGV2LCBpbnQgcGh5X2lkLCBpbnQgcmVnKQogewogCXN0cnVjdCByODE1MiAqdHAgPSBuZXRkZXZfcHJpdihuZXRkZXYpOwpAQCAtMjUxOCwyNCArMjUwNiwxOCBAQAogCWRhdGEgPSBvY3BfcmVnX3JlYWQodHAsIE9DUF9QT1dFUl9DRkcpOwogCWRhdGEgfD0gRU5fMTBNX1BMTE9GRjsKIAlvY3BfcmVnX3dyaXRlKHRwLCBPQ1BfUE9XRVJfQ0ZHLCBkYXRhKTsKLQlkYXRhID0gc3JhbV9yZWFkKHRwLCBTUkFNX0lNUEVEQU5DRSk7Ci0JZGF0YSAmPSB+UlhfRFJJVklOR19NQVNLOwotCXNyYW1fd3JpdGUodHAsIFNSQU1fSU1QRURBTkNFLCBkYXRhKTsKKwlzcmFtX3dyaXRlKHRwLCBTUkFNX0lNUEVEQU5DRSwgMHgwYjEzKTsKIAogCW9jcF9kYXRhID0gb2NwX3JlYWRfd29yZCh0cCwgTUNVX1RZUEVfUExBLCBQTEFfUEhZX1BXUik7CiAJb2NwX2RhdGEgfD0gUEZNX1BXTV9TV0lUQ0g7CiAJb2NwX3dyaXRlX3dvcmQodHAsIE1DVV9UWVBFX1BMQSwgUExBX1BIWV9QV1IsIG9jcF9kYXRhKTsKIAotCWRhdGEgPSBzcmFtX3JlYWQodHAsIFNSQU1fTFBGX0NGRyk7Ci0JZGF0YSB8PSBMUEZfQVVUT19UVU5FOwotCXNyYW1fd3JpdGUodHAsIFNSQU1fTFBGX0NGRywgZGF0YSk7CisJLyogRW5hYmxlIExQRiBjb3JuZXIgYXV0byB0dW5lICovCisJc3JhbV93cml0ZSh0cCwgU1JBTV9MUEZfQ0ZHLCAweGY3MGYpOwogCi0JZGF0YSA9IHNyYW1fcmVhZCh0cCwgU1JBTV8xME1fQU1QMSk7Ci0JZGF0YSB8PSBHREFDX0lCX1VQQUxMOwotCXNyYW1fd3JpdGUodHAsIFNSQU1fMTBNX0FNUDEsIGRhdGEpOwotCWRhdGEgPSBzcmFtX3JlYWQodHAsIFNSQU1fMTBNX0FNUDIpOwotCWRhdGEgfD0gQU1QX0ROOwotCXNyYW1fd3JpdGUodHAsIFNSQU1fMTBNX0FNUDIsIGRhdGEpOworCS8qIEFkanVzdCAxME0gQW1wbGl0dWRlICovCisJc3JhbV93cml0ZSh0cCwgU1JBTV8xME1fQU1QMSwgMHgwMGFmKTsKKwlzcmFtX3dyaXRlKHRwLCBTUkFNXzEwTV9BTVAyLCAweDAyMDgpOwogCiAJc2V0X2JpdChQSFlfUkVTRVQsICZ0cC0+ZmxhZ3MpOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvdXNiL3NyOTcwMC5jIGIvZHJpdmVycy9uZXQvdXNiL3NyOTcwMC5jCmluZGV4IDk5YjY5YWYuLjRhMWU5YzQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3VzYi9zcjk3MDAuYworKysgYi9kcml2ZXJzL25ldC91c2Ivc3I5NzAwLmMKQEAgLTc3LDcgKzc3LDcgQEAKIAkJaW50IHJldDsKIAogCQl1ZGVsYXkoMSk7Ci0JCXJldCA9IHNyX3JlYWRfcmVnKGRldiwgRVBDUiwgJnRtcCk7CisJCXJldCA9IHNyX3JlYWRfcmVnKGRldiwgU1JfRVBDUiwgJnRtcCk7CiAJCWlmIChyZXQgPCAwKQogCQkJcmV0dXJuIHJldDsKIApAQCAtOTgsMTUgKzk4LDE1IEBACiAKIAltdXRleF9sb2NrKCZkZXYtPnBoeV9tdXRleCk7CiAKLQlzcl93cml0ZV9yZWcoZGV2LCBFUEFSLCBwaHkgPyAocmVnIHwgRVBBUl9QSFlfQURSKSA6IHJlZyk7Ci0Jc3Jfd3JpdGVfcmVnKGRldiwgRVBDUiwgcGh5ID8gKEVQQ1JfRVBPUyB8IEVQQ1JfRVJQUlIpIDogRVBDUl9FUlBSUik7CisJc3Jfd3JpdGVfcmVnKGRldiwgU1JfRVBBUiwgcGh5ID8gKHJlZyB8IEVQQVJfUEhZX0FEUikgOiByZWcpOworCXNyX3dyaXRlX3JlZyhkZXYsIFNSX0VQQ1IsIHBoeSA/IChFUENSX0VQT1MgfCBFUENSX0VSUFJSKSA6IEVQQ1JfRVJQUlIpOwogCiAJcmV0ID0gd2FpdF9waHlfZWVwcm9tX3JlYWR5KGRldiwgcGh5KTsKIAlpZiAocmV0IDwgMCkKIAkJZ290byBvdXRfdW5sb2NrOwogCi0Jc3Jfd3JpdGVfcmVnKGRldiwgRVBDUiwgMHgwKTsKLQlyZXQgPSBzcl9yZWFkKGRldiwgRVBEUiwgMiwgdmFsdWUpOworCXNyX3dyaXRlX3JlZyhkZXYsIFNSX0VQQ1IsIDB4MCk7CisJcmV0ID0gc3JfcmVhZChkZXYsIFNSX0VQRFIsIDIsIHZhbHVlKTsKIAogCW5ldGRldl9kYmcoZGV2LT5uZXQsICJyZWFkIHNoYXJlZCAlZCAweCUwMnggcmV0dXJuZWQgMHglMDR4LCAlZFxuIiwKIAkJICAgcGh5LCByZWcsICp2YWx1ZSwgcmV0KTsKQEAgLTEyMywxOSArMTIzLDE5IEBACiAKIAltdXRleF9sb2NrKCZkZXYtPnBoeV9tdXRleCk7CiAKLQlyZXQgPSBzcl93cml0ZShkZXYsIEVQRFIsIDIsICZ2YWx1ZSk7CisJcmV0ID0gc3Jfd3JpdGUoZGV2LCBTUl9FUERSLCAyLCAmdmFsdWUpOwogCWlmIChyZXQgPCAwKQogCQlnb3RvIG91dF91bmxvY2s7CiAKLQlzcl93cml0ZV9yZWcoZGV2LCBFUEFSLCBwaHkgPyAocmVnIHwgRVBBUl9QSFlfQURSKSA6IHJlZyk7Ci0Jc3Jfd3JpdGVfcmVnKGRldiwgRVBDUiwgcGh5ID8gKEVQQ1JfV0VQIHwgRVBDUl9FUE9TIHwgRVBDUl9FUlBSVykgOgorCXNyX3dyaXRlX3JlZyhkZXYsIFNSX0VQQVIsIHBoeSA/IChyZWcgfCBFUEFSX1BIWV9BRFIpIDogcmVnKTsKKwlzcl93cml0ZV9yZWcoZGV2LCBTUl9FUENSLCBwaHkgPyAoRVBDUl9XRVAgfCBFUENSX0VQT1MgfCBFUENSX0VSUFJXKSA6CiAJCSAgICAoRVBDUl9XRVAgfCBFUENSX0VSUFJXKSk7CiAKIAlyZXQgPSB3YWl0X3BoeV9lZXByb21fcmVhZHkoZGV2LCBwaHkpOwogCWlmIChyZXQgPCAwKQogCQlnb3RvIG91dF91bmxvY2s7CiAKLQlzcl93cml0ZV9yZWcoZGV2LCBFUENSLCAweDApOworCXNyX3dyaXRlX3JlZyhkZXYsIFNSX0VQQ1IsIDB4MCk7CiAKIG91dF91bmxvY2s6CiAJbXV0ZXhfdW5sb2NrKCZkZXYtPnBoeV9tdXRleCk7CkBAIC0xODgsNyArMTg4LDcgQEAKIAlpZiAobG9jID09IE1JSV9CTVNSKSB7CiAJCXU4IHZhbHVlOwogCi0JCXNyX3JlYWRfcmVnKGRldiwgTlNSLCAmdmFsdWUpOworCQlzcl9yZWFkX3JlZyhkZXYsIFNSX05TUiwgJnZhbHVlKTsKIAkJaWYgKHZhbHVlICYgTlNSX0xJTktTVCkKIAkJCXJjID0gMTsKIAl9CkBAIC0yMjgsNyArMjI4LDcgQEAKIAlpbnQgcmMgPSAwOwogCiAJLyogR2V0IHRoZSBMaW5rIFN0YXR1cyBkaXJlY3RseSAqLwotCXNyX3JlYWRfcmVnKGRldiwgTlNSLCAmdmFsdWUpOworCXNyX3JlYWRfcmVnKGRldiwgU1JfTlNSLCAmdmFsdWUpOwogCWlmICh2YWx1ZSAmIE5TUl9MSU5LU1QpCiAJCXJjID0gMTsKIApAQCAtMjgxLDggKzI4MSw4IEBACiAJCX0KIAl9CiAKLQlzcl93cml0ZV9hc3luYyhkZXYsIE1BUiwgU1JfTUNBU1RfU0laRSwgaGFzaGVzKTsKLQlzcl93cml0ZV9yZWdfYXN5bmMoZGV2LCBSQ1IsIHJ4X2N0bCk7CisJc3Jfd3JpdGVfYXN5bmMoZGV2LCBTUl9NQVIsIFNSX01DQVNUX1NJWkUsIGhhc2hlcyk7CisJc3Jfd3JpdGVfcmVnX2FzeW5jKGRldiwgU1JfUkNSLCByeF9jdGwpOwogfQogCiBzdGF0aWMgaW50IHNyOTcwMF9zZXRfbWFjX2FkZHJlc3Moc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldiwgdm9pZCAqcCkKQEAgLTI5Nyw3ICsyOTcsNyBAQAogCX0KIAogCW1lbWNweShuZXRkZXYtPmRldl9hZGRyLCBhZGRyLT5zYV9kYXRhLCBuZXRkZXYtPmFkZHJfbGVuKTsKLQlzcl93cml0ZV9hc3luYyhkZXYsIFBBUiwgNiwgbmV0ZGV2LT5kZXZfYWRkcik7CisJc3Jfd3JpdGVfYXN5bmMoZGV2LCBTUl9QQVIsIDYsIG5ldGRldi0+ZGV2X2FkZHIpOwogCiAJcmV0dXJuIDA7CiB9CkBAIC0zNDAsNyArMzQwLDcgQEAKIAltaWktPnBoeV9pZF9tYXNrID0gMHgxZjsKIAltaWktPnJlZ19udW1fbWFzayA9IDB4MWY7CiAKLQlzcl93cml0ZV9yZWcoZGV2LCBOQ1IsIE5DUl9SU1QpOworCXNyX3dyaXRlX3JlZyhkZXYsIFNSX05DUiwgTkNSX1JTVCk7CiAJdWRlbGF5KDIwKTsKIAogCS8qIHJlYWQgTUFDCkBAIC0zNDgsMTcgKzM0OCwxNyBAQAogCSAqIEVFUFJPTSBhdXRvbWF0aWNhbGx5IHRvIFBBUi4gSW4gY2FzZSB0aGVyZSBpcyBubyBFRVBST00gZXh0ZXJuYWxseSwKIAkgKiBhIGRlZmF1bHQgTUFDIGFkZHJlc3MgaXMgc3RvcmVkIGluIFBBUiBmb3IgbWFraW5nIGNoaXAgd29yayBwcm9wZXJseS4KIAkgKi8KLQlpZiAoc3JfcmVhZChkZXYsIFBBUiwgRVRIX0FMRU4sIG5ldGRldi0+ZGV2X2FkZHIpIDwgMCkgeworCWlmIChzcl9yZWFkKGRldiwgU1JfUEFSLCBFVEhfQUxFTiwgbmV0ZGV2LT5kZXZfYWRkcikgPCAwKSB7CiAJCW5ldGRldl9lcnIobmV0ZGV2LCAiRXJyb3IgcmVhZGluZyBNQUMgYWRkcmVzc1xuIik7CiAJCXJldCA9IC1FTk9ERVY7CiAJCWdvdG8gb3V0OwogCX0KIAogCS8qIHBvd2VyIHVwIGFuZCByZXNldCBwaHkgKi8KLQlzcl93cml0ZV9yZWcoZGV2LCBQUlIsIFBSUl9QSFlfUlNUKTsKKwlzcl93cml0ZV9yZWcoZGV2LCBTUl9QUlIsIFBSUl9QSFlfUlNUKTsKIAkvKiBhdCBsZWFzdCAxMG1zLCBoZXJlIDIwbXMgZm9yIHNhZmUgKi8KIAltZGVsYXkoMjApOwotCXNyX3dyaXRlX3JlZyhkZXYsIFBSUiwgMCk7CisJc3Jfd3JpdGVfcmVnKGRldiwgU1JfUFJSLCAwKTsKIAkvKiBhdCBsZWFzdCAxbXMsIGhlcmUgMm1zIGZvciByZWFkaW5nIHJpZ2h0IHJlZ2lzdGVyICovCiAJdWRlbGF5KDIgKiAxMDAwKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvdXNiL3NyOTcwMC5oIGIvZHJpdmVycy9uZXQvdXNiL3NyOTcwMC5oCmluZGV4IGZkNjg3YzUuLjI1OGIwMzAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3VzYi9zcjk3MDAuaAorKysgYi9kcml2ZXJzL25ldC91c2Ivc3I5NzAwLmgKQEAgLTE0LDEzICsxNCwxMyBAQAogLyogc3I5NzAwIHNwZWMuIHJlZ2lzdGVyIHRhYmxlIG9uIExpbnV4IHBsYXRmb3JtICovCiAKIC8qIE5ldHdvcmsgQ29udHJvbCBSZWcgKi8KLSNkZWZpbmUJTkNSCQkJMHgwMAorI2RlZmluZQlTUl9OQ1IJCQkweDAwCiAjZGVmaW5lCQlOQ1JfUlNUCQkJKDEgPDwgMCkKICNkZWZpbmUJCU5DUl9MQksJCQkoMyA8PCAxKQogI2RlZmluZQkJTkNSX0ZEWAkJCSgxIDw8IDMpCiAjZGVmaW5lCQlOQ1JfV0FLRUVOCQkoMSA8PCA2KQogLyogTmV0d29yayBTdGF0dXMgUmVnICovCi0jZGVmaW5lCU5TUgkJCTB4MDEKKyNkZWZpbmUJU1JfTlNSCQkJMHgwMQogI2RlZmluZQkJTlNSX1JYUkRZCQkoMSA8PCAwKQogI2RlZmluZQkJTlNSX1JYT1YJCSgxIDw8IDEpCiAjZGVmaW5lCQlOU1JfVFgxRU5ECQkoMSA8PCAyKQpAQCAtMzAsNyArMzAsNyBAQAogI2RlZmluZQkJTlNSX0xJTktTVAkJKDEgPDwgNikKICNkZWZpbmUJCU5TUl9TUEVFRAkJKDEgPDwgNykKIC8qIFR4IENvbnRyb2wgUmVnICovCi0jZGVmaW5lCVRDUgkJCTB4MDIKKyNkZWZpbmUJU1JfVENSCQkJMHgwMgogI2RlZmluZQkJVENSX0NSQ19ESVMJCSgxIDw8IDEpCiAjZGVmaW5lCQlUQ1JfUEFEX0RJUwkJKDEgPDwgMikKICNkZWZpbmUJCVRDUl9MQ19DQVJFCQkoMSA8PCAzKQpAQCAtMzgsNyArMzgsNyBAQAogI2RlZmluZQkJVENSX0VYQ0VDTQkJKDEgPDwgNSkKICNkZWZpbmUJCVRDUl9MRl9FTgkJKDEgPDwgNikKIC8qIFR4IFN0YXR1cyBSZWcgZm9yIFBhY2tldCBJbmRleCAxICovCi0jZGVmaW5lCVRTUjEJCTB4MDMKKyNkZWZpbmUJU1JfVFNSMQkJMHgwMwogI2RlZmluZQkJVFNSMV9FQwkJCSgxIDw8IDIpCiAjZGVmaW5lCQlUU1IxX0NPTAkJKDEgPDwgMykKICNkZWZpbmUJCVRTUjFfTEMJCQkoMSA8PCA0KQpAQCAtNDYsNyArNDYsNyBAQAogI2RlZmluZQkJVFNSMV9MT0MJCSgxIDw8IDYpCiAjZGVmaW5lCQlUU1IxX1RMRgkJKDEgPDwgNykKIC8qIFR4IFN0YXR1cyBSZWcgZm9yIFBhY2tldCBJbmRleCAyICovCi0jZGVmaW5lCVRTUjIJCTB4MDQKKyNkZWZpbmUJU1JfVFNSMgkJMHgwNAogI2RlZmluZQkJVFNSMl9FQwkJCSgxIDw8IDIpCiAjZGVmaW5lCQlUU1IyX0NPTAkJKDEgPDwgMykKICNkZWZpbmUJCVRTUjJfTEMJCQkoMSA8PCA0KQpAQCAtNTQsNyArNTQsNyBAQAogI2RlZmluZQkJVFNSMl9MT0MJCSgxIDw8IDYpCiAjZGVmaW5lCQlUU1IyX1RMRgkJKDEgPDwgNykKIC8qIFJ4IENvbnRyb2wgUmVnKi8KLSNkZWZpbmUJUkNSCQkJMHgwNQorI2RlZmluZQlTUl9SQ1IJCQkweDA1CiAjZGVmaW5lCQlSQ1JfUlhFTgkJKDEgPDwgMCkKICNkZWZpbmUJCVJDUl9QUk1TQwkJKDEgPDwgMSkKICNkZWZpbmUJCVJDUl9SVU5UCQkoMSA8PCAyKQpAQCAtNjIsODcgKzYyLDg3IEBACiAjZGVmaW5lCQlSQ1JfRElTX0NSQwkJKDEgPDwgNCkKICNkZWZpbmUJCVJDUl9ESVNfTE9ORwkoMSA8PCA1KQogLyogUnggU3RhdHVzIFJlZyAqLwotI2RlZmluZQlSU1IJCQkweDA2CisjZGVmaW5lCVNSX1JTUgkJCTB4MDYKICNkZWZpbmUJCVJTUl9BRQkJCSgxIDw8IDIpCiAjZGVmaW5lCQlSU1JfTUYJCQkoMSA8PCA2KQogI2RlZmluZQkJUlNSX1JGCQkJKDEgPDwgNykKIC8qIFJ4IE92ZXJmbG93IENvdW50ZXIgUmVnICovCi0jZGVmaW5lCVJPQ1IJCTB4MDcKKyNkZWZpbmUJU1JfUk9DUgkJMHgwNwogI2RlZmluZQkJUk9DUl9ST0MJCSgweDdGIDw8IDApCiAjZGVmaW5lCQlST0NSX1JYRlUJCSgxIDw8IDcpCiAvKiBCYWNrIFByZXNzdXJlIFRocmVzaG9sZCBSZWcgKi8KLSNkZWZpbmUJQlBUUgkJMHgwOAorI2RlZmluZQlTUl9CUFRSCQkweDA4CiAjZGVmaW5lCQlCUFRSX0pQVAkJKDB4MEYgPDwgMCkKICNkZWZpbmUJCUJQVFJfQlBIVwkJKDB4MEYgPDwgNCkKIC8qIEZsb3cgQ29udHJvbCBUaHJlc2hvbGQgUmVnICovCi0jZGVmaW5lCUZDVFIJCTB4MDkKKyNkZWZpbmUJU1JfRkNUUgkJMHgwOQogI2RlZmluZQkJRkNUUl9MV09UCQkoMHgwRiA8PCAwKQogI2RlZmluZQkJRkNUUl9IV09UCQkoMHgwRiA8PCA0KQogLyogcngvdHggRmxvdyBDb250cm9sIFJlZyAqLwotI2RlZmluZQlGQ1IJCQkweDBBCisjZGVmaW5lCVNSX0ZDUgkJCTB4MEEKICNkZWZpbmUJCUZDUl9GTENFCQkoMSA8PCAwKQogI2RlZmluZQkJRkNSX0JLUEEJCSgxIDw8IDQpCiAjZGVmaW5lCQlGQ1JfVFhQRU4JCSgxIDw8IDUpCiAjZGVmaW5lCQlGQ1JfVFhQRgkJKDEgPDwgNikKICNkZWZpbmUJCUZDUl9UWFAwCQkoMSA8PCA3KQogLyogRWVwcm9tICYgUGh5IENvbnRyb2wgUmVnICovCi0jZGVmaW5lCUVQQ1IJCTB4MEIKKyNkZWZpbmUJU1JfRVBDUgkJMHgwQgogI2RlZmluZQkJRVBDUl9FUlJFCQkoMSA8PCAwKQogI2RlZmluZQkJRVBDUl9FUlBSVwkJKDEgPDwgMSkKICNkZWZpbmUJCUVQQ1JfRVJQUlIJCSgxIDw8IDIpCiAjZGVmaW5lCQlFUENSX0VQT1MJCSgxIDw8IDMpCiAjZGVmaW5lCQlFUENSX1dFUAkJKDEgPDwgNCkKIC8qIEVlcHJvbSAmIFBoeSBBZGRyZXNzIFJlZyAqLwotI2RlZmluZQlFUEFSCQkweDBDCisjZGVmaW5lCVNSX0VQQVIJCTB4MEMKICNkZWZpbmUJCUVQQVJfRVJPQQkJKDB4M0YgPDwgMCkKICNkZWZpbmUJCUVQQVJfUEhZX0FEUl9NQVNLCSgweDAzIDw8IDYpCiAjZGVmaW5lCQlFUEFSX1BIWV9BRFIJCSgweDAxIDw8IDYpCiAvKiBFZXByb20gJglQaHkgRGF0YSBSZWcgKi8KLSNkZWZpbmUJRVBEUgkJMHgwRAkvKiAweDBEIH4gMHgwRSBmb3IgRGF0YSBSZWcgTG93ICYgSGlnaCAqLworI2RlZmluZQlTUl9FUERSCQkweDBECS8qIDB4MEQgfiAweDBFIGZvciBEYXRhIFJlZyBMb3cgJiBIaWdoICovCiAvKiBXYWtldXAgQ29udHJvbCBSZWcgKi8KLSNkZWZpbmUJV0NSCQkJMHgwRgorI2RlZmluZQlTUl9XQ1IJCQkweDBGCiAjZGVmaW5lCQlXQ1JfTUFHSUNTVAkJKDEgPDwgMCkKICNkZWZpbmUJCVdDUl9MSU5LU1QJCSgxIDw8IDIpCiAjZGVmaW5lCQlXQ1JfTUFHSUNFTgkJKDEgPDwgMykKICNkZWZpbmUJCVdDUl9MSU5LRU4JCSgxIDw8IDUpCiAvKiBQaHlzaWNhbCBBZGRyZXNzIFJlZyAqLwotI2RlZmluZQlQQVIJCQkweDEwCS8qIDB4MTAgfiAweDE1IDYgYnl0ZXMgZm9yIFBBUiAqLworI2RlZmluZQlTUl9QQVIJCQkweDEwCS8qIDB4MTAgfiAweDE1IDYgYnl0ZXMgZm9yIFBBUiAqLwogLyogTXVsdGljYXN0IEFkZHJlc3MgUmVnICovCi0jZGVmaW5lCU1BUgkJCTB4MTYJLyogMHgxNiB+IDB4MUQgOCBieXRlcyBmb3IgTUFSICovCisjZGVmaW5lCVNSX01BUgkJCTB4MTYJLyogMHgxNiB+IDB4MUQgOCBieXRlcyBmb3IgTUFSICovCiAvKiAweDFlIHVudXNlZCAqLwogLyogUGh5IFJlc2V0IFJlZyAqLwotI2RlZmluZQlQUlIJCQkweDFGCisjZGVmaW5lCVNSX1BSUgkJCTB4MUYKICNkZWZpbmUJCVBSUl9QSFlfUlNUCQkoMSA8PCAwKQogLyogVHggc2RyYW0gV3JpdGUgUG9pbnRlciBBZGRyZXNzIExvdyAqLwotI2RlZmluZQlUV1BBTAkJMHgyMAorI2RlZmluZQlTUl9UV1BBTAkJMHgyMAogLyogVHggc2RyYW0gV3JpdGUgUG9pbnRlciBBZGRyZXNzIEhpZ2ggKi8KLSNkZWZpbmUJVFdQQUgJCTB4MjEKKyNkZWZpbmUJU1JfVFdQQUgJCTB4MjEKIC8qIFR4IHNkcmFtIFJlYWQgUG9pbnRlciBBZGRyZXNzIExvdyAqLwotI2RlZmluZQlUUlBBTAkJMHgyMgorI2RlZmluZQlTUl9UUlBBTAkJMHgyMgogLyogVHggc2RyYW0gUmVhZCBQb2ludGVyIEFkZHJlc3MgSGlnaCAqLwotI2RlZmluZQlUUlBBSAkJMHgyMworI2RlZmluZQlTUl9UUlBBSAkJMHgyMwogLyogUnggc2RyYW0gV3JpdGUgUG9pbnRlciBBZGRyZXNzIExvdyAqLwotI2RlZmluZQlSV1BBTAkJMHgyNAorI2RlZmluZQlTUl9SV1BBTAkJMHgyNAogLyogUnggc2RyYW0gV3JpdGUgUG9pbnRlciBBZGRyZXNzIEhpZ2ggKi8KLSNkZWZpbmUJUldQQUgJCTB4MjUKKyNkZWZpbmUJU1JfUldQQUgJCTB4MjUKIC8qIFJ4IHNkcmFtIFJlYWQgUG9pbnRlciBBZGRyZXNzIExvdyAqLwotI2RlZmluZQlSUlBBTAkJMHgyNgorI2RlZmluZQlTUl9SUlBBTAkJMHgyNgogLyogUnggc2RyYW0gUmVhZCBQb2ludGVyIEFkZHJlc3MgSGlnaCAqLwotI2RlZmluZQlSUlBBSAkJMHgyNworI2RlZmluZQlTUl9SUlBBSAkJMHgyNwogLyogVmVuZG9yIElEIHJlZ2lzdGVyICovCi0jZGVmaW5lCVZJRAkJCTB4MjgJLyogMHgyOCB+IDB4MjkgMiBieXRlcyBmb3IgVklEICovCisjZGVmaW5lCVNSX1ZJRAkJCTB4MjgJLyogMHgyOCB+IDB4MjkgMiBieXRlcyBmb3IgVklEICovCiAvKiBQcm9kdWN0IElEIHJlZ2lzdGVyICovCi0jZGVmaW5lCVBJRAkJCTB4MkEJLyogMHgyQSB+IDB4MkIgMiBieXRlcyBmb3IgUElEICovCisjZGVmaW5lCVNSX1BJRAkJCTB4MkEJLyogMHgyQSB+IDB4MkIgMiBieXRlcyBmb3IgUElEICovCiAvKiBDSElQIFJldmlzaW9uIHJlZ2lzdGVyICovCi0jZGVmaW5lCUNISVBSCQkweDJDCisjZGVmaW5lCVNSX0NISVBSCQkweDJDCiAvKiAweDJEIC0tPiAweEVGIHVudXNlZCAqLwogLyogVVNCIERldmljZSBBZGRyZXNzICovCi0jZGVmaW5lCVVTQkRBCQkweEYwCisjZGVmaW5lCVNSX1VTQkRBCQkweEYwCiAjZGVmaW5lCQlVU0JEQV9VU0JGQQkJKDB4N0YgPDwgMCkKIC8qIFJYIHBhY2tldCBDb3VudGVyIFJlZyAqLwotI2RlZmluZQlSWEMJCQkweEYxCisjZGVmaW5lCVNSX1JYQwkJCTB4RjEKIC8qIFR4IHBhY2tldCBDb3VudGVyICYgVVNCIFN0YXR1cyBSZWcgKi8KLSNkZWZpbmUJVFhDX1VTQlMJMHhGMgorI2RlZmluZQlTUl9UWENfVVNCUwkJMHhGMgogI2RlZmluZQkJVFhDX1VTQlNfVFhDMAkJKDEgPDwgMCkKICNkZWZpbmUJCVRYQ19VU0JTX1RYQzEJCSgxIDw8IDEpCiAjZGVmaW5lCQlUWENfVVNCU19UWEMyCQkoMSA8PCAyKQpAQCAtMTUwLDcgKzE1MCw3IEBACiAjZGVmaW5lCQlUWENfVVNCU19TVVNGTEFHCSgxIDw8IDYpCiAjZGVmaW5lCQlUWENfVVNCU19SWEZBVUxUCSgxIDw8IDcpCiAvKiBVU0IgQ29udHJvbCByZWdpc3RlciAqLwotI2RlZmluZQlVU0JDCQkweEY0CisjZGVmaW5lCVNSX1VTQkMJCQkweEY0CiAjZGVmaW5lCQlVU0JDX0VQM05BSwkJKDEgPDwgNCkKICNkZWZpbmUJCVVTQkNfRVAzQUNLCQkoMSA8PCA1KQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC92aXJ0aW9fbmV0LmMgYi9kcml2ZXJzL25ldC92aXJ0aW9fbmV0LmMKaW5kZXggNWNhOTc3MS4uMDU5ZmRmMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvdmlydGlvX25ldC5jCisrKyBiL2RyaXZlcnMvbmV0L3ZpcnRpb19uZXQuYwpAQCAtNDkwLDE3ICs0OTAsOCBAQAogCQkJc2tiX3NoaW5mbyhza2IpLT5nc29fdHlwZSA9IFNLQl9HU09fVENQVjQ7CiAJCQlicmVhazsKIAkJY2FzZSBWSVJUSU9fTkVUX0hEUl9HU09fVURQOgotCQl7Ci0JCQlzdGF0aWMgYm9vbCB3YXJuZWQ7Ci0KLQkJCWlmICghd2FybmVkKSB7Ci0JCQkJd2FybmVkID0gdHJ1ZTsKLQkJCQluZXRkZXZfd2FybihkZXYsCi0JCQkJCSAgICAiaG9zdCB1c2luZyBkaXNhYmxlZCBVRk8gZmVhdHVyZTsgcGxlYXNlIGZpeCBpdFxuIik7Ci0JCQl9CiAJCQlza2Jfc2hpbmZvKHNrYiktPmdzb190eXBlID0gU0tCX0dTT19VRFA7CiAJCQlicmVhazsKLQkJfQogCQljYXNlIFZJUlRJT19ORVRfSERSX0dTT19UQ1BWNjoKIAkJCXNrYl9zaGluZm8oc2tiKS0+Z3NvX3R5cGUgPSBTS0JfR1NPX1RDUFY2OwogCQkJYnJlYWs7CkBAIC04ODgsNiArODc5LDggQEAKIAkJCWhkci0+aGRyLmdzb190eXBlID0gVklSVElPX05FVF9IRFJfR1NPX1RDUFY0OwogCQllbHNlIGlmIChza2Jfc2hpbmZvKHNrYiktPmdzb190eXBlICYgU0tCX0dTT19UQ1BWNikKIAkJCWhkci0+aGRyLmdzb190eXBlID0gVklSVElPX05FVF9IRFJfR1NPX1RDUFY2OworCQllbHNlIGlmIChza2Jfc2hpbmZvKHNrYiktPmdzb190eXBlICYgU0tCX0dTT19VRFApCisJCQloZHItPmhkci5nc29fdHlwZSA9IFZJUlRJT19ORVRfSERSX0dTT19VRFA7CiAJCWVsc2UKIAkJCUJVRygpOwogCQlpZiAoc2tiX3NoaW5mbyhza2IpLT5nc29fdHlwZSAmIFNLQl9HU09fVENQX0VDTikKQEAgLTE3NDgsNyArMTc0MSw3IEBACiAJCQlkZXYtPmZlYXR1cmVzIHw9IE5FVElGX0ZfSFdfQ1NVTXxORVRJRl9GX1NHfE5FVElGX0ZfRlJBR0xJU1Q7CiAKIAkJaWYgKHZpcnRpb19oYXNfZmVhdHVyZSh2ZGV2LCBWSVJUSU9fTkVUX0ZfR1NPKSkgewotCQkJZGV2LT5od19mZWF0dXJlcyB8PSBORVRJRl9GX1RTTworCQkJZGV2LT5od19mZWF0dXJlcyB8PSBORVRJRl9GX1RTTyB8IE5FVElGX0ZfVUZPCiAJCQkJfCBORVRJRl9GX1RTT19FQ04gfCBORVRJRl9GX1RTTzY7CiAJCX0KIAkJLyogSW5kaXZpZHVhbCBmZWF0dXJlIGJpdHM6IHdoYXQgY2FuIGhvc3QgaGFuZGxlPyAqLwpAQCAtMTc1OCw5ICsxNzUxLDExIEBACiAJCQlkZXYtPmh3X2ZlYXR1cmVzIHw9IE5FVElGX0ZfVFNPNjsKIAkJaWYgKHZpcnRpb19oYXNfZmVhdHVyZSh2ZGV2LCBWSVJUSU9fTkVUX0ZfSE9TVF9FQ04pKQogCQkJZGV2LT5od19mZWF0dXJlcyB8PSBORVRJRl9GX1RTT19FQ047CisJCWlmICh2aXJ0aW9faGFzX2ZlYXR1cmUodmRldiwgVklSVElPX05FVF9GX0hPU1RfVUZPKSkKKwkJCWRldi0+aHdfZmVhdHVyZXMgfD0gTkVUSUZfRl9VRk87CiAKIAkJaWYgKGdzbykKLQkJCWRldi0+ZmVhdHVyZXMgfD0gZGV2LT5od19mZWF0dXJlcyAmIE5FVElGX0ZfQUxMX1RTTzsKKwkJCWRldi0+ZmVhdHVyZXMgfD0gZGV2LT5od19mZWF0dXJlcyAmIChORVRJRl9GX0FMTF9UU098TkVUSUZfRl9VRk8pOwogCQkvKiAoIWNzdW0gJiYgZ3NvKSBjYXNlIHdpbGwgYmUgZml4ZWQgYnkgcmVnaXN0ZXJfbmV0ZGV2KCkgKi8KIAl9CiAJaWYgKHZpcnRpb19oYXNfZmVhdHVyZSh2ZGV2LCBWSVJUSU9fTkVUX0ZfR1VFU1RfQ1NVTSkpCkBAIC0xNzk4LDcgKzE3OTMsOCBAQAogCS8qIElmIHdlIGNhbiByZWNlaXZlIEFOWSBHU08gcGFja2V0cywgd2UgbXVzdCBhbGxvY2F0ZSBsYXJnZSBvbmVzLiAqLwogCWlmICh2aXJ0aW9faGFzX2ZlYXR1cmUodmRldiwgVklSVElPX05FVF9GX0dVRVNUX1RTTzQpIHx8CiAJICAgIHZpcnRpb19oYXNfZmVhdHVyZSh2ZGV2LCBWSVJUSU9fTkVUX0ZfR1VFU1RfVFNPNikgfHwKLQkgICAgdmlydGlvX2hhc19mZWF0dXJlKHZkZXYsIFZJUlRJT19ORVRfRl9HVUVTVF9FQ04pKQorCSAgICB2aXJ0aW9faGFzX2ZlYXR1cmUodmRldiwgVklSVElPX05FVF9GX0dVRVNUX0VDTikgfHwKKwkgICAgdmlydGlvX2hhc19mZWF0dXJlKHZkZXYsIFZJUlRJT19ORVRfRl9HVUVTVF9VRk8pKQogCQl2aS0+YmlnX3BhY2tldHMgPSB0cnVlOwogCiAJaWYgKHZpcnRpb19oYXNfZmVhdHVyZSh2ZGV2LCBWSVJUSU9fTkVUX0ZfTVJHX1JYQlVGKSkKQEAgLTE5OTQsOSArMTk5MCw5IEBACiBzdGF0aWMgdW5zaWduZWQgaW50IGZlYXR1cmVzW10gPSB7CiAJVklSVElPX05FVF9GX0NTVU0sIFZJUlRJT19ORVRfRl9HVUVTVF9DU1VNLAogCVZJUlRJT19ORVRfRl9HU08sIFZJUlRJT19ORVRfRl9NQUMsCi0JVklSVElPX05FVF9GX0hPU1RfVFNPNCwgVklSVElPX05FVF9GX0hPU1RfVFNPNiwKKwlWSVJUSU9fTkVUX0ZfSE9TVF9UU080LCBWSVJUSU9fTkVUX0ZfSE9TVF9VRk8sIFZJUlRJT19ORVRfRl9IT1NUX1RTTzYsCiAJVklSVElPX05FVF9GX0hPU1RfRUNOLCBWSVJUSU9fTkVUX0ZfR1VFU1RfVFNPNCwgVklSVElPX05FVF9GX0dVRVNUX1RTTzYsCi0JVklSVElPX05FVF9GX0dVRVNUX0VDTiwKKwlWSVJUSU9fTkVUX0ZfR1VFU1RfRUNOLCBWSVJUSU9fTkVUX0ZfR1VFU1RfVUZPLAogCVZJUlRJT19ORVRfRl9NUkdfUlhCVUYsIFZJUlRJT19ORVRfRl9TVEFUVVMsIFZJUlRJT19ORVRfRl9DVFJMX1ZRLAogCVZJUlRJT19ORVRfRl9DVFJMX1JYLCBWSVJUSU9fTkVUX0ZfQ1RSTF9WTEFOLAogCVZJUlRJT19ORVRfRl9HVUVTVF9BTk5PVU5DRSwgVklSVElPX05FVF9GX01RLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvdnhsYW4uYyBiL2RyaXZlcnMvbmV0L3Z4bGFuLmMKaW5kZXggN2ZiZDg5Zi4uYThjNzU1ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvdnhsYW4uYworKysgYi9kcml2ZXJzL25ldC92eGxhbi5jCkBAIC0yNDMyLDEwICsyNDMyLDEwIEBACiAJZGV2X3B1dCh2eGxhbi0+ZGV2KTsKIH0KIAotc3RhdGljIGludCB2eGxhbl9uZXdsaW5rKHN0cnVjdCBuZXQgKm5ldCwgc3RydWN0IG5ldF9kZXZpY2UgKmRldiwKK3N0YXRpYyBpbnQgdnhsYW5fbmV3bGluayhzdHJ1Y3QgbmV0ICpzcmNfbmV0LCBzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LAogCQkJIHN0cnVjdCBubGF0dHIgKnRiW10sIHN0cnVjdCBubGF0dHIgKmRhdGFbXSkKIHsKLQlzdHJ1Y3QgdnhsYW5fbmV0ICp2biA9IG5ldF9nZW5lcmljKG5ldCwgdnhsYW5fbmV0X2lkKTsKKwlzdHJ1Y3QgdnhsYW5fbmV0ICp2biA9IG5ldF9nZW5lcmljKHNyY19uZXQsIHZ4bGFuX25ldF9pZCk7CiAJc3RydWN0IHZ4bGFuX2RldiAqdnhsYW4gPSBuZXRkZXZfcHJpdihkZXYpOwogCXN0cnVjdCB2eGxhbl9yZHN0ICpkc3QgPSAmdnhsYW4tPmRlZmF1bHRfZHN0OwogCV9fdTMyIHZuaTsKQEAgLTI0NDUsNyArMjQ0NSw3IEBACiAJaWYgKCFkYXRhW0lGTEFfVlhMQU5fSURdKQogCQlyZXR1cm4gLUVJTlZBTDsKIAotCXZ4bGFuLT5uZXQgPSBkZXZfbmV0KGRldik7CisJdnhsYW4tPm5ldCA9IHNyY19uZXQ7CiAKIAl2bmkgPSBubGFfZ2V0X3UzMihkYXRhW0lGTEFfVlhMQU5fSURdKTsKIAlkc3QtPnJlbW90ZV92bmkgPSB2bmk7CkBAIC0yNDgxLDcgKzI0ODEsNyBAQAogCWlmIChkYXRhW0lGTEFfVlhMQU5fTElOS10gJiYKIAkgICAgKGRzdC0+cmVtb3RlX2lmaW5kZXggPSBubGFfZ2V0X3UzMihkYXRhW0lGTEFfVlhMQU5fTElOS10pKSkgewogCQlzdHJ1Y3QgbmV0X2RldmljZSAqbG93ZXJkZXYKLQkJCSA9IF9fZGV2X2dldF9ieV9pbmRleChuZXQsIGRzdC0+cmVtb3RlX2lmaW5kZXgpOworCQkJID0gX19kZXZfZ2V0X2J5X2luZGV4KHNyY19uZXQsIGRzdC0+cmVtb3RlX2lmaW5kZXgpOwogCiAJCWlmICghbG93ZXJkZXYpIHsKIAkJCXByX2luZm8oImlmaW5kZXggJWQgZG9lcyBub3QgZXhpc3RcbiIsIGRzdC0+cmVtb3RlX2lmaW5kZXgpOwpAQCAtMjU1Nyw3ICsyNTU3LDcgQEAKIAkgICAgbmxhX2dldF91OChkYXRhW0lGTEFfVlhMQU5fVURQX1pFUk9fQ1NVTTZfUlhdKSkKIAkJdnhsYW4tPmZsYWdzIHw9IFZYTEFOX0ZfVURQX1pFUk9fQ1NVTTZfUlg7CiAKLQlpZiAodnhsYW5fZmluZF92bmkobmV0LCB2bmksIHVzZV9pcHY2ID8gQUZfSU5FVDYgOiBBRl9JTkVULAorCWlmICh2eGxhbl9maW5kX3ZuaShzcmNfbmV0LCB2bmksIHVzZV9pcHY2ID8gQUZfSU5FVDYgOiBBRl9JTkVULAogCQkJICAgdnhsYW4tPmRzdF9wb3J0KSkgewogCQlwcl9pbmZvKCJkdXBsaWNhdGUgVk5JICV1XG4iLCB2bmkpOwogCQlyZXR1cm4gLUVFWElTVDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dhbi9LY29uZmlnIGIvZHJpdmVycy9uZXQvd2FuL0tjb25maWcKaW5kZXggOTRlMjM0OS4uYTJmZGQxNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2FuL0tjb25maWcKKysrIGIvZHJpdmVycy9uZXQvd2FuL0tjb25maWcKQEAgLTI1LDcgKzI1LDcgQEAKICMgVGhlcmUgaXMgbm8gd2F5IHRvIGRldGVjdCBhIGNvbXRyb2wgc3YxMSAtIGZvcmNlIGl0IG1vZHVsYXIgZm9yIG5vdy4KIGNvbmZpZyBIT1NURVNTX1NWMTEKIAl0cmlzdGF0ZSAiQ29tdHJvbCBIb3N0ZXNzIFNWLTExIHN1cHBvcnQiCi0JZGVwZW5kcyBvbiBJU0EgJiYgbSAmJiBJU0FfRE1BX0FQSSAmJiBJTkVUICYmIEhETEMKKwlkZXBlbmRzIG9uIElTQSAmJiBtICYmIElTQV9ETUFfQVBJICYmIElORVQgJiYgSERMQyAmJiBWSVJUX1RPX0JVUwogCWhlbHAKIAkgIERyaXZlciBmb3IgQ29tdHJvbCBIb3N0ZXNzIFNWLTExIG5ldHdvcmsgY2FyZCB3aGljaAogCSAgb3BlcmF0ZXMgb24gbG93IHNwZWVkIHN5bmNocm9ub3VzIHNlcmlhbCBsaW5rcyBhdCB1cCB0bwpAQCAtMzcsNyArMzcsNyBAQAogIyBUaGUgQ09TQS9TUlAgZHJpdmVyIGhhcyBub3QgYmVlbiB0ZXN0ZWQgYXMgbm9uLW1vZHVsYXIgeWV0LgogY29uZmlnIENPU0EKIAl0cmlzdGF0ZSAiQ09TQS9TUlAgc3luYyBzZXJpYWwgYm9hcmRzIHN1cHBvcnQiCi0JZGVwZW5kcyBvbiBJU0EgJiYgbSAmJiBJU0FfRE1BX0FQSSAmJiBIRExDCisJZGVwZW5kcyBvbiBJU0EgJiYgbSAmJiBJU0FfRE1BX0FQSSAmJiBIRExDICYmIFZJUlRfVE9fQlVTCiAJLS0taGVscC0tLQogCSAgRHJpdmVyIGZvciBDT1NBIGFuZCBTUlAgc3luY2hyb25vdXMgc2VyaWFsIGJvYXJkcy4KIApAQCAtODcsNyArODcsNyBAQAogIyBUaGVyZSBpcyBubyB3YXkgdG8gZGV0ZWN0IGEgU2VhbGV2ZWwgYm9hcmQuIEZvcmNlIGl0IG1vZHVsYXIKIGNvbmZpZyBTRUFMRVZFTF80MDIxCiAJdHJpc3RhdGUgIlNlYWxldmVsIFN5c3RlbXMgNDAyMSBzdXBwb3J0IgotCWRlcGVuZHMgb24gSVNBICYmIG0gJiYgSVNBX0RNQV9BUEkgJiYgSU5FVCAmJiBIRExDCisJZGVwZW5kcyBvbiBJU0EgJiYgbSAmJiBJU0FfRE1BX0FQSSAmJiBJTkVUICYmIEhETEMgJiYgVklSVF9UT19CVVMKIAloZWxwCiAJICBUaGlzIGlzIGEgZHJpdmVyIGZvciB0aGUgU2VhbGV2ZWwgU3lzdGVtcyBBQ0IgNTYgc2VyaWFsIEkvTyBhZGFwdGVyLgogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoOWsvbWFpbi5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDlrL21haW4uYwppbmRleCA5YTcyNjQwLi42MmIwYmY0IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoOWsvbWFpbi5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9tYWluLmMKQEAgLTI4NSw2ICsyODUsNyBAQAogCiAJX19hdGhfY2FuY2VsX3dvcmsoc2MpOwogCisJZGlzYWJsZV9pcnEoc2MtPmlycSk7CiAJdGFza2xldF9kaXNhYmxlKCZzYy0+aW50cl90cSk7CiAJdGFza2xldF9kaXNhYmxlKCZzYy0+YmNvbl90YXNrbGV0KTsKIAlzcGluX2xvY2tfYmgoJnNjLT5zY19wY3VfbG9jayk7CkBAIC0zMzEsNiArMzMyLDcgQEAKIAkJciA9IC1FSU87CiAKIG91dDoKKwllbmFibGVfaXJxKHNjLT5pcnEpOwogCXNwaW5fdW5sb2NrX2JoKCZzYy0+c2NfcGN1X2xvY2spOwogCXRhc2tsZXRfZW5hYmxlKCZzYy0+YmNvbl90YXNrbGV0KTsKIAl0YXNrbGV0X2VuYWJsZSgmc2MtPmludHJfdHEpOwpAQCAtNTEyLDkgKzUxNCw2IEBACiAJaWYgKCFhaCB8fCB0ZXN0X2JpdChBVEhfT1BfSU5WQUxJRCwgJmNvbW1vbi0+b3BfZmxhZ3MpKQogCQlyZXR1cm4gSVJRX05PTkU7CiAKLQlpZiAoIUFSX1NSRVZfOTEwMChhaCkgJiYgdGVzdF9iaXQoQVRIX09QX0hXX1JFU0VULCAmY29tbW9uLT5vcF9mbGFncykpCi0JCXJldHVybiBJUlFfTk9ORTsKLQogCS8qIHNoYXJlZCBpcnEsIG5vdCBmb3IgdXMgKi8KIAlpZiAoIWF0aDlrX2h3X2ludHJwZW5kKGFoKSkKIAkJcmV0dXJuIElSUV9OT05FOwpAQCAtNTI5LDcgKzUyOCw3IEBACiAJYXRoOWtfZGVidWdfc3luY19jYXVzZShzYywgc3luY19jYXVzZSk7CiAJc3RhdHVzICY9IGFoLT5pbWFzazsJLyogZGlzY2FyZCB1bmFza2VkLWZvciBiaXRzICovCiAKLQlpZiAoQVJfU1JFVl85MTAwKGFoKSAmJiB0ZXN0X2JpdChBVEhfT1BfSFdfUkVTRVQsICZjb21tb24tPm9wX2ZsYWdzKSkKKwlpZiAodGVzdF9iaXQoQVRIX09QX0hXX1JFU0VULCAmY29tbW9uLT5vcF9mbGFncykpCiAJCXJldHVybiBJUlFfSEFORExFRDsKIAogCS8qCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2x3aWZpL2l3bC1mdy1maWxlLmggYi9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2x3aWZpL2l3bC1mdy1maWxlLmgKaW5kZXggMWJiZTRmYy4uNjYwZGRiMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtZnctZmlsZS5oCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLWZ3LWZpbGUuaApAQCAtMjQ2LDYgKzI0Niw3IEBACiAgKiBASVdMX1VDT0RFX1RMVl9BUElfQkFTSUNfRFdFTEw6IHVzZSBvbmx5IGJhc2ljIGR3ZWxsIHRpbWUgaW4gc2NhbiBjb21tYW5kLAogICoJcmVnYXJkbGVzcyBvZiB0aGUgYmFuZCBvciB0aGUgbnVtYmVyIG9mIHRoZSBwcm9iZXMuIEZXIHdpbGwgY2FsY3VsYXRlCiAgKgl0aGUgYWN0dWFsIGR3ZWxsIHRpbWUuCisgKiBASVdMX1VDT0RFX1RMVl9BUElfU0lOR0xFX1NDQU5fRUJTOiBFQlMgaXMgc3VwcG9ydGVkIGZvciBzaW5nbGUgc2NhbnMgdG9vLgogICovCiBlbnVtIGl3bF91Y29kZV90bHZfYXBpIHsKIAlJV0xfVUNPREVfVExWX0FQSV9XT1dMQU5fQ09ORklHX1RJRAk9IEJJVCgwKSwKQEAgLTI1Nyw2ICsyNTgsNyBAQAogCUlXTF9VQ09ERV9UTFZfQVBJX1NGX05PX0RVTU1ZX05PVElGCT0gQklUKDcpLAogCUlXTF9VQ09ERV9UTFZfQVBJX0ZSQUdNRU5URURfU0NBTgk9IEJJVCg4KSwKIAlJV0xfVUNPREVfVExWX0FQSV9CQVNJQ19EV0VMTAkJPSBCSVQoMTMpLAorCUlXTF9VQ09ERV9UTFZfQVBJX1NJTkdMRV9TQ0FOX0VCUwk9IEJJVCgxNiksCiB9OwogCiAvKioKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvbXZtL2Z3LWFwaS1zY2FuLmggYi9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2x3aWZpL212bS9mdy1hcGktc2Nhbi5oCmluZGV4IDIwMTg0NmQuLmNmYzBlNjUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvbXZtL2Z3LWFwaS1zY2FuLmgKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9tdm0vZnctYXBpLXNjYW4uaApAQCAtNjUzLDggKzY1MywxMSBAQAogfTsKIAogLyogaXdsX3NjYW5fY2hhbm5lbF9vcHQgLSBDSEFOTkVMX09QVElNSVpBVElPTl9BUElfUwotICogQGZsYWdzOiBlbnVtIGl3bF9zY2FuX2NoYW5uZWxfZmxncwotICogQG5vbl9lYnNfcmF0aW86IGhvdyBtYW55IHJlZ3VsYXIgc2NhbiBpdGVyYXRpb24gYmVmb3JlIEVCUworICogQGZsYWdzOiBlbnVtIGl3bF9zY2FuX2NoYW5uZWxfZmxhZ3MKKyAqIEBub25fZWJzX3JhdGlvOiBkZWZpbmVzIHRoZSByYXRpbyBvZiBudW1iZXIgb2Ygc2NhbiBpdGVyYXRpb25zIHdoZXJlIEVCUyBpcworICoJaW52b2x2ZWQuCisgKgkxIC0gRUJTIGlzIGRpc2FibGVkLgorICoJMiAtIGV2ZXJ5IHNlY29uZCBzY2FuIHdpbGwgYmUgZnVsbCBzY2FuKGFuZCBzbyBvbikuCiAgKi8KIHN0cnVjdCBpd2xfc2Nhbl9jaGFubmVsX29wdCB7CiAJX19sZTE2IGZsYWdzOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9tdm0vbWFjODAyMTEuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvbXZtL21hYzgwMjExLmMKaW5kZXggZTg4MGY5ZC4uMjA5MTU1OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9tdm0vbWFjODAyMTEuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2x3aWZpL212bS9tYWM4MDIxMS5jCkBAIC0zMzQzLDE4ICszMzQzLDE2IEBACiAJCW1zayB8PSBtdm1zdGEtPnRmZF9xdWV1ZV9tc2s7CiAJfQogCi0JaWYgKGRyb3ApIHsKLQkJaWYgKGl3bF9tdm1fZmx1c2hfdHhfcGF0aChtdm0sIG1zaywgdHJ1ZSkpCi0JCQlJV0xfRVJSKG12bSwgImZsdXNoIHJlcXVlc3QgZmFpbFxuIik7Ci0JCW11dGV4X3VubG9jaygmbXZtLT5tdXRleCk7Ci0JfSBlbHNlIHsKLQkJbXV0ZXhfdW5sb2NrKCZtdm0tPm11dGV4KTsKKwltc2sgJj0gfkJJVCh2aWYtPmh3X3F1ZXVlW0lFRUU4MDIxMV9BQ19WT10pOwogCi0JCS8qIHRoaXMgY2FuIHRha2UgYSB3aGlsZSwgYW5kIHdlIG1heSBuZWVkL3dhbnQgb3RoZXIgb3BlcmF0aW9ucwotCQkgKiB0byBzdWNjZWVkIHdoaWxlIGRvaW5nIHRoaXMsIHNvIGRvIGl0IHdpdGhvdXQgdGhlIG11dGV4IGhlbGQKLQkJICovCi0JCWl3bF90cmFuc193YWl0X3R4X3F1ZXVlX2VtcHR5KG12bS0+dHJhbnMsIG1zayk7Ci0JfQorCWlmIChpd2xfbXZtX2ZsdXNoX3R4X3BhdGgobXZtLCBtc2ssIHRydWUpKQorCQlJV0xfRVJSKG12bSwgImZsdXNoIHJlcXVlc3QgZmFpbFxuIik7CisJbXV0ZXhfdW5sb2NrKCZtdm0tPm11dGV4KTsKKworCS8qIHRoaXMgY2FuIHRha2UgYSB3aGlsZSwgYW5kIHdlIG1heSBuZWVkL3dhbnQgb3RoZXIgb3BlcmF0aW9ucworCSAqIHRvIHN1Y2NlZWQgd2hpbGUgZG9pbmcgdGhpcywgc28gZG8gaXQgd2l0aG91dCB0aGUgbXV0ZXggaGVsZAorCSAqLworCWl3bF90cmFuc193YWl0X3R4X3F1ZXVlX2VtcHR5KG12bS0+dHJhbnMsIG1zayk7CiB9CiAKIGNvbnN0IHN0cnVjdCBpZWVlODAyMTFfb3BzIGl3bF9tdm1faHdfb3BzID0gewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9tdm0vc2Nhbi5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9tdm0vc2Nhbi5jCmluZGV4IGVjOWE4ZTcuLjg0NGJmN2MgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvbXZtL3NjYW4uYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2x3aWZpL212bS9zY2FuLmMKQEAgLTcyLDYgKzcyLDggQEAKIAogI2RlZmluZSBJV0xfUExDUF9RVUlFVF9USFJFU0ggMQogI2RlZmluZSBJV0xfQUNUSVZFX1FVSUVUX1RJTUUgMTAKKyNkZWZpbmUgSVdMX0RFTlNFX0VCU19TQ0FOX1JBVElPIDUKKyNkZWZpbmUgSVdMX1NQQVJTRV9FQlNfU0NBTl9SQVRJTyAxCiAKIHN0cnVjdCBpd2xfbXZtX3NjYW5fcGFyYW1zIHsKIAl1MzIgbWF4X291dF90aW1lOwpAQCAtMTEwNSw2ICsxMTA3LDEyIEBACiAJCXJldHVybiBpd2xfdW1hY19zY2FuX3N0b3AobXZtLCBJV0xfVU1BQ19TQ0FOX1VJRF9TQ0hFRF9TQ0FOLAogCQkJCQkgIG5vdGlmeSk7CiAKKwlpZiAobXZtLT5zY2FuX3N0YXR1cyA9PSBJV0xfTVZNX1NDQU5fTk9ORSkKKwkJcmV0dXJuIDA7CisKKwlpZiAoaXdsX212bV9pc19yYWRpb19raWxsZWQobXZtKSkKKwkJZ290byBvdXQ7CisKIAlpZiAobXZtLT5zY2FuX3N0YXR1cyAhPSBJV0xfTVZNX1NDQU5fU0NIRUQgJiYKIAkgICAgKCEobXZtLT5mdy0+dWNvZGVfY2FwYS5hcGlbMF0gJiBJV0xfVUNPREVfVExWX0FQSV9MTUFDX1NDQU4pIHx8CiAJICAgICBtdm0tPnNjYW5fc3RhdHVzICE9IElXTF9NVk1fU0NBTl9PUykpIHsKQEAgLTExNDEsNiArMTE0OSw3IEBACiAJaWYgKG12bS0+c2Nhbl9zdGF0dXMgPT0gSVdMX01WTV9TQ0FOX09TKQogCQlpd2xfbXZtX3VucmVmKG12bSwgSVdMX01WTV9SRUZfU0NBTik7CiAKK291dDoKIAltdm0tPnNjYW5fc3RhdHVzID0gSVdMX01WTV9TQ0FOX05PTkU7CiAKIAlpZiAobm90aWZ5KSB7CkBAIC0xMjk3LDE4ICsxMzA2LDYgQEAKIAljbWQtPnNjYW5fcHJpbyA9IGNwdV90b19sZTMyKElXTF9TQ0FOX1BSSU9SSVRZX0hJR0gpOwogCWNtZC0+aXRlcl9udW0gPSBjcHVfdG9fbGUzMigxKTsKIAotCWlmIChtdm0tPmZ3LT51Y29kZV9jYXBhLmZsYWdzICYgSVdMX1VDT0RFX1RMVl9GTEFHU19FQlNfU1VQUE9SVCAmJgotCSAgICBtdm0tPmxhc3RfZWJzX3N1Y2Nlc3NmdWwpIHsKLQkJY21kLT5jaGFubmVsX29wdFswXS5mbGFncyA9Ci0JCQljcHVfdG9fbGUxNihJV0xfU0NBTl9DSEFOTkVMX0ZMQUdfRUJTIHwKLQkJCQkgICAgSVdMX1NDQU5fQ0hBTk5FTF9GTEFHX0VCU19BQ0NVUkFURSB8Ci0JCQkJICAgIElXTF9TQ0FOX0NIQU5ORUxfRkxBR19DQUNIRV9BREQpOwotCQljbWQtPmNoYW5uZWxfb3B0WzFdLmZsYWdzID0KLQkJCWNwdV90b19sZTE2KElXTF9TQ0FOX0NIQU5ORUxfRkxBR19FQlMgfAotCQkJCSAgICBJV0xfU0NBTl9DSEFOTkVMX0ZMQUdfRUJTX0FDQ1VSQVRFIHwKLQkJCQkgICAgSVdMX1NDQU5fQ0hBTk5FTF9GTEFHX0NBQ0hFX0FERCk7Ci0JfQotCiAJaWYgKGl3bF9tdm1fcnJtX3NjYW5fbmVlZGVkKG12bSkpCiAJCWNtZC0+c2Nhbl9mbGFncyB8PQogCQkJY3B1X3RvX2xlMzIoSVdMX01WTV9MTUFDX1NDQU5fRkxBR1NfUlJNX0VOQUJMRUQpOwpAQCAtMTM4Myw2ICsxMzgwLDIyIEBACiAJY21kLT5zY2hlZHVsZVsxXS5pdGVyYXRpb25zID0gMDsKIAljbWQtPnNjaGVkdWxlWzFdLmZ1bGxfc2Nhbl9tdWwgPSAwOwogCisJaWYgKG12bS0+ZnctPnVjb2RlX2NhcGEuYXBpWzBdICYgSVdMX1VDT0RFX1RMVl9BUElfU0lOR0xFX1NDQU5fRUJTICYmCisJICAgIG12bS0+bGFzdF9lYnNfc3VjY2Vzc2Z1bCkgeworCQljbWQtPmNoYW5uZWxfb3B0WzBdLmZsYWdzID0KKwkJCWNwdV90b19sZTE2KElXTF9TQ0FOX0NIQU5ORUxfRkxBR19FQlMgfAorCQkJCSAgICBJV0xfU0NBTl9DSEFOTkVMX0ZMQUdfRUJTX0FDQ1VSQVRFIHwKKwkJCQkgICAgSVdMX1NDQU5fQ0hBTk5FTF9GTEFHX0NBQ0hFX0FERCk7CisJCWNtZC0+Y2hhbm5lbF9vcHRbMF0ubm9uX2Vic19yYXRpbyA9CisJCQljcHVfdG9fbGUxNihJV0xfREVOU0VfRUJTX1NDQU5fUkFUSU8pOworCQljbWQtPmNoYW5uZWxfb3B0WzFdLmZsYWdzID0KKwkJCWNwdV90b19sZTE2KElXTF9TQ0FOX0NIQU5ORUxfRkxBR19FQlMgfAorCQkJCSAgICBJV0xfU0NBTl9DSEFOTkVMX0ZMQUdfRUJTX0FDQ1VSQVRFIHwKKwkJCQkgICAgSVdMX1NDQU5fQ0hBTk5FTF9GTEFHX0NBQ0hFX0FERCk7CisJCWNtZC0+Y2hhbm5lbF9vcHRbMV0ubm9uX2Vic19yYXRpbyA9CisJCQljcHVfdG9fbGUxNihJV0xfU1BBUlNFX0VCU19TQ0FOX1JBVElPKTsKKwl9CisKIAlmb3IgKGkgPSAxOyBpIDw9IHJlcS0+cmVxLm5fc3NpZHM7IGkrKykKIAkJc3NpZF9iaXRtYXAgfD0gQklUKGkpOwogCkBAIC0xNDgzLDYgKzE0OTYsMjIgQEAKIAljbWQtPnNjaGVkdWxlWzFdLml0ZXJhdGlvbnMgPSAweGZmOwogCWNtZC0+c2NoZWR1bGVbMV0uZnVsbF9zY2FuX211bCA9IElXTF9GVUxMX1NDQU5fTVVMVElQTElFUjsKIAorCWlmIChtdm0tPmZ3LT51Y29kZV9jYXBhLmZsYWdzICYgSVdMX1VDT0RFX1RMVl9GTEFHU19FQlNfU1VQUE9SVCAmJgorCSAgICBtdm0tPmxhc3RfZWJzX3N1Y2Nlc3NmdWwpIHsKKwkJY21kLT5jaGFubmVsX29wdFswXS5mbGFncyA9CisJCQljcHVfdG9fbGUxNihJV0xfU0NBTl9DSEFOTkVMX0ZMQUdfRUJTIHwKKwkJCQkgICAgSVdMX1NDQU5fQ0hBTk5FTF9GTEFHX0VCU19BQ0NVUkFURSB8CisJCQkJICAgIElXTF9TQ0FOX0NIQU5ORUxfRkxBR19DQUNIRV9BREQpOworCQljbWQtPmNoYW5uZWxfb3B0WzBdLm5vbl9lYnNfcmF0aW8gPQorCQkJY3B1X3RvX2xlMTYoSVdMX0RFTlNFX0VCU19TQ0FOX1JBVElPKTsKKwkJY21kLT5jaGFubmVsX29wdFsxXS5mbGFncyA9CisJCQljcHVfdG9fbGUxNihJV0xfU0NBTl9DSEFOTkVMX0ZMQUdfRUJTIHwKKwkJCQkgICAgSVdMX1NDQU5fQ0hBTk5FTF9GTEFHX0VCU19BQ0NVUkFURSB8CisJCQkJICAgIElXTF9TQ0FOX0NIQU5ORUxfRkxBR19DQUNIRV9BREQpOworCQljbWQtPmNoYW5uZWxfb3B0WzFdLm5vbl9lYnNfcmF0aW8gPQorCQkJY3B1X3RvX2xlMTYoSVdMX1NQQVJTRV9FQlNfU0NBTl9SQVRJTyk7CisJfQorCiAJaXdsX212bV9sbWFjX3NjYW5fY2ZnX2NoYW5uZWxzKG12bSwgcmVxLT5jaGFubmVscywgcmVxLT5uX2NoYW5uZWxzLAogCQkJCSAgICAgICBzc2lkX2JpdG1hcCwgY21kKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9tdm0vdHguYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvbXZtL3R4LmMKaW5kZXggNDMzMzMwNi4uYzU5ZDA3NSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9tdm0vdHguYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2x3aWZpL212bS90eC5jCkBAIC05MCw4ICs5MCw2IEBACiAKIAlpZiAoaWVlZTgwMjExX2lzX3Byb2JlX3Jlc3AoZmMpKQogCQl0eF9mbGFncyB8PSBUWF9DTURfRkxHX1RTRjsKLQllbHNlIGlmIChpZWVlODAyMTFfaXNfYmFja19yZXEoZmMpKQotCQl0eF9mbGFncyB8PSBUWF9DTURfRkxHX0FDSyB8IFRYX0NNRF9GTEdfQkFSOwogCiAJaWYgKGllZWU4MDIxMV9oYXNfbW9yZWZyYWdzKGZjKSkKIAkJdHhfZmxhZ3MgfD0gVFhfQ01EX0ZMR19NT1JFX0ZSQUc7CkBAIC0xMDAsNiArOTgsMTUgQEAKIAkJdTggKnFjID0gaWVlZTgwMjExX2dldF9xb3NfY3RsKGhkcik7CiAJCXR4X2NtZC0+dGlkX3RzcGVjID0gcWNbMF0gJiAweGY7CiAJCXR4X2ZsYWdzICY9IH5UWF9DTURfRkxHX1NFUV9DVEw7CisJfSBlbHNlIGlmIChpZWVlODAyMTFfaXNfYmFja19yZXEoZmMpKSB7CisJCXN0cnVjdCBpZWVlODAyMTFfYmFyICpiYXIgPSAodm9pZCAqKXNrYi0+ZGF0YTsKKwkJdTE2IGNvbnRyb2wgPSBsZTE2X3RvX2NwdShiYXItPmNvbnRyb2wpOworCisJCXR4X2ZsYWdzIHw9IFRYX0NNRF9GTEdfQUNLIHwgVFhfQ01EX0ZMR19CQVI7CisJCXR4X2NtZC0+dGlkX3RzcGVjID0gKGNvbnRyb2wgJgorCQkJCSAgICAgSUVFRTgwMjExX0JBUl9DVFJMX1RJRF9JTkZPX01BU0spID4+CisJCQlJRUVFODAyMTFfQkFSX0NUUkxfVElEX0lORk9fU0hJRlQ7CisJCVdBUk5fT05fT05DRSh0eF9jbWQtPnRpZF90c3BlYyA+PSBJV0xfTUFYX1RJRF9DT1VOVCk7CiAJfSBlbHNlIHsKIAkJdHhfY21kLT50aWRfdHNwZWMgPSBJV0xfVElEX05PTl9RT1M7CiAJCWlmIChpbmZvLT5mbGFncyAmIElFRUU4MDIxMV9UWF9DVExfQVNTSUdOX1NFUSkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3hlbi1uZXRiYWNrL2ludGVyZmFjZS5jIGIvZHJpdmVycy9uZXQveGVuLW5ldGJhY2svaW50ZXJmYWNlLmMKaW5kZXggOTI1OWE3My4uMDM3Zjc0ZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQveGVuLW5ldGJhY2svaW50ZXJmYWNlLmMKKysrIGIvZHJpdmVycy9uZXQveGVuLW5ldGJhY2svaW50ZXJmYWNlLmMKQEAgLTU3OCw2ICs1NzgsNyBAQAogCQlnb3RvIGVycl9yeF91bmJpbmQ7CiAJfQogCXF1ZXVlLT50YXNrID0gdGFzazsKKwlnZXRfdGFza19zdHJ1Y3QodGFzayk7CiAKIAl0YXNrID0ga3RocmVhZF9jcmVhdGUoeGVudmlmX2RlYWxsb2Nfa3RocmVhZCwKIAkJCSAgICAgICh2b2lkICopcXVldWUsICIlcy1kZWFsbG9jIiwgcXVldWUtPm5hbWUpOwpAQCAtNjM0LDYgKzYzNSw3IEBACiAKIAkJaWYgKHF1ZXVlLT50YXNrKSB7CiAJCQlrdGhyZWFkX3N0b3AocXVldWUtPnRhc2spOworCQkJcHV0X3Rhc2tfc3RydWN0KHF1ZXVlLT50YXNrKTsKIAkJCXF1ZXVlLT50YXNrID0gTlVMTDsKIAkJfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC94ZW4tbmV0YmFjay9uZXRiYWNrLmMgYi9kcml2ZXJzL25ldC94ZW4tbmV0YmFjay9uZXRiYWNrLmMKaW5kZXggOTA4ZTY1ZS4uYzhjZTcwMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQveGVuLW5ldGJhY2svbmV0YmFjay5jCisrKyBiL2RyaXZlcnMvbmV0L3hlbi1uZXRiYWNrL25ldGJhY2suYwpAQCAtMjEwOSw4ICsyMTA5LDcgQEAKIAkJICovCiAJCWlmICh1bmxpa2VseSh2aWYtPmRpc2FibGVkICYmIHF1ZXVlLT5pZCA9PSAwKSkgewogCQkJeGVudmlmX2NhcnJpZXJfb2ZmKHZpZik7Ci0JCQl4ZW52aWZfcnhfcXVldWVfcHVyZ2UocXVldWUpOwotCQkJY29udGludWU7CisJCQlicmVhazsKIAkJfQogCiAJCWlmICghc2tiX3F1ZXVlX2VtcHR5KCZxdWV1ZS0+cnhfcXVldWUpKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9vZi9vZl9wY2kuYyBiL2RyaXZlcnMvb2Yvb2ZfcGNpLmMKaW5kZXggODg0NzFkMy4uNjI0MjZkOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9vZi9vZl9wY2kuYworKysgYi9kcml2ZXJzL29mL29mX3BjaS5jCkBAIC0xNDAsNiArMTQwLDcgQEAKIAkJCXVuc2lnbmVkIGNoYXIgYnVzbm8sIHVuc2lnbmVkIGNoYXIgYnVzX21heCwKIAkJCXN0cnVjdCBsaXN0X2hlYWQgKnJlc291cmNlcywgcmVzb3VyY2Vfc2l6ZV90ICppb19iYXNlKQogeworCXN0cnVjdCByZXNvdXJjZV9lbnRyeSAqd2luZG93OwogCXN0cnVjdCByZXNvdXJjZSAqcmVzOwogCXN0cnVjdCByZXNvdXJjZSAqYnVzX3JhbmdlOwogCXN0cnVjdCBvZl9wY2lfcmFuZ2UgcmFuZ2U7CkBAIC0yMjUsNiArMjI2LDggQEAKIGNvbnZlcnNpb25fZmFpbGVkOgogCWtmcmVlKHJlcyk7CiBwYXJzZV9mYWlsZWQ6CisJcmVzb3VyY2VfbGlzdF9mb3JfZWFjaF9lbnRyeSh3aW5kb3csIHJlc291cmNlcykKKwkJa2ZyZWUod2luZG93LT5yZXMpOwogCXBjaV9mcmVlX3Jlc291cmNlX2xpc3QocmVzb3VyY2VzKTsKIAlyZXR1cm4gZXJyOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9vZi9vdmVybGF5LmMgYi9kcml2ZXJzL29mL292ZXJsYXkuYwppbmRleCBlYTYzZmJkMi4uMzUyYjRmMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9vZi9vdmVybGF5LmMKKysrIGIvZHJpdmVycy9vZi9vdmVybGF5LmMKQEAgLTExNCwxNyArMTE0LDYgQEAKIAkJcmV0ID0gb2Zfb3ZlcmxheV9hcHBseV9vbmUob3YsIHRjaGlsZCwgY2hpbGQpOwogCQlpZiAocmV0KQogCQkJcmV0dXJuIHJldDsKLQotCQkvKiBUaGUgcHJvcGVydGllcyBhcmUgYWxyZWFkeSBjb3BpZWQsIG5vdyBkbyB0aGUgY2hpbGQgbm9kZXMgKi8KLQkJZm9yX2VhY2hfY2hpbGRfb2Zfbm9kZShjaGlsZCwgZ3JhbmRjaGlsZCkgewotCQkJcmV0ID0gb2Zfb3ZlcmxheV9hcHBseV9zaW5nbGVfZGV2aWNlX25vZGUob3YsIHRjaGlsZCwgZ3JhbmRjaGlsZCk7Ci0JCQlpZiAocmV0KSB7Ci0JCQkJcHJfZXJyKCIlczogRmFpbGVkIHRvIGFwcGx5IHNpbmdsZSBub2RlIEAlcy8lc1xuIiwKLQkJCQkJX19mdW5jX18sIHRjaGlsZC0+ZnVsbF9uYW1lLAotCQkJCQlncmFuZGNoaWxkLT5uYW1lKTsKLQkJCQlyZXR1cm4gcmV0OwotCQkJfQotCQl9CiAJfQogCiAJcmV0dXJuIHJldDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvb2YvcGxhdGZvcm0uYyBiL2RyaXZlcnMvb2YvcGxhdGZvcm0uYwppbmRleCA1YjMzYzZhLi5iMGQ1MGQ3IDEwMDY0NAotLS0gYS9kcml2ZXJzL29mL3BsYXRmb3JtLmMKKysrIGIvZHJpdmVycy9vZi9wbGF0Zm9ybS5jCkBAIC0xODgsNyArMTg4LDcgQEAKIAkJc2l6ZSA9IGRldi0+Y29oZXJlbnRfZG1hX21hc2s7CiAJfSBlbHNlIHsKIAkJb2Zmc2V0ID0gUEZOX0RPV04ocGFkZHIgLSBkbWFfYWRkcik7Ci0JCWRldl9kYmcoZGV2LCAiZG1hX3Bmbl9vZmZzZXQoJSMwOGx4KVxuIiwgZGV2LT5kbWFfcGZuX29mZnNldCk7CisJCWRldl9kYmcoZGV2LCAiZG1hX3Bmbl9vZmZzZXQoJSMwOGx4KVxuIiwgb2Zmc2V0KTsKIAl9CiAJZGV2LT5kbWFfcGZuX29mZnNldCA9IG9mZnNldDsKIApAQCAtNTY2LDYgKzU2NiwxMCBAQAogCQlpZiAoIW9mX25vZGVfY2hlY2tfZmxhZyhyZC0+ZG4tPnBhcmVudCwgT0ZfUE9QVUxBVEVEX0JVUykpCiAJCQlyZXR1cm4gTk9USUZZX09LOwkvKiBub3QgZm9yIHVzICovCiAKKwkJLyogYWxyZWFkeSBwb3B1bGF0ZWQ/IChkcml2ZXIgdXNpbmcgb2ZfcG9wdWxhdGUgbWFudWFsbHkpICovCisJCWlmIChvZl9ub2RlX2NoZWNrX2ZsYWcocmQtPmRuLCBPRl9QT1BVTEFURUQpKQorCQkJcmV0dXJuIE5PVElGWV9PSzsKKwogCQkvKiBwZGV2X3BhcmVudCBtYXkgYmUgTlVMTCB3aGVuIG5vIGJ1cyBwbGF0Zm9ybSBkZXZpY2UgKi8KIAkJcGRldl9wYXJlbnQgPSBvZl9maW5kX2RldmljZV9ieV9ub2RlKHJkLT5kbi0+cGFyZW50KTsKIAkJcGRldiA9IG9mX3BsYXRmb3JtX2RldmljZV9jcmVhdGUocmQtPmRuLCBOVUxMLApAQCAtNTgxLDYgKzU4NSwxMSBAQAogCQlicmVhazsKIAogCWNhc2UgT0ZfUkVDT05GSUdfQ0hBTkdFX1JFTU9WRToKKworCQkvKiBhbHJlYWR5IGRlcG9wdWxhdGVkPyAqLworCQlpZiAoIW9mX25vZGVfY2hlY2tfZmxhZyhyZC0+ZG4sIE9GX1BPUFVMQVRFRCkpCisJCQlyZXR1cm4gTk9USUZZX09LOworCiAJCS8qIGZpbmQgb3VyIGRldmljZSBieSBub2RlICovCiAJCXBkZXYgPSBvZl9maW5kX2RldmljZV9ieV9ub2RlKHJkLT5kbik7CiAJCWlmIChwZGV2ID09IE5VTEwpCmRpZmYgLS1naXQgYS9kcml2ZXJzL29mL3VuaXR0ZXN0LWRhdGEvdGVzdHMtb3ZlcmxheS5kdHNpIGIvZHJpdmVycy9vZi91bml0dGVzdC1kYXRhL3Rlc3RzLW92ZXJsYXkuZHRzaQppbmRleCA3NTk3NmRhLi5hMmI2ODdkIDEwMDY0NAotLS0gYS9kcml2ZXJzL29mL3VuaXR0ZXN0LWRhdGEvdGVzdHMtb3ZlcmxheS5kdHNpCisrKyBiL2RyaXZlcnMvb2YvdW5pdHRlc3QtZGF0YS90ZXN0cy1vdmVybGF5LmR0c2kKQEAgLTE3Niw1ICsxNzYsNjAgQEAKIAkJCX07CiAJCX07CiAKKwkJb3ZlcmxheTEwIHsKKwkJCWZyYWdtZW50QDAgeworCQkJCXRhcmdldC1wYXRoID0gIi90ZXN0Y2FzZS1kYXRhL292ZXJsYXktbm9kZS90ZXN0LWJ1cyI7CisJCQkJX19vdmVybGF5X18geworCisJCQkJCS8qIHN1cHByZXNzIERUQyB3YXJuaW5nICovCisJCQkJCSNhZGRyZXNzLWNlbGxzID0gPDE+OworCQkJCQkjc2l6ZS1jZWxscyA9IDwwPjsKKworCQkJCQl0ZXN0LXNlbGZ0ZXN0MTAgeworCQkJCQkJY29tcGF0aWJsZSA9ICJzZWxmdGVzdCI7CisJCQkJCQlzdGF0dXMgPSAib2theSI7CisJCQkJCQlyZWcgPSA8MTA+OworCisJCQkJCQkjYWRkcmVzcy1jZWxscyA9IDwxPjsKKwkJCQkJCSNzaXplLWNlbGxzID0gPDA+OworCisJCQkJCQl0ZXN0LXNlbGZ0ZXN0MTAxIHsKKwkJCQkJCQljb21wYXRpYmxlID0gInNlbGZ0ZXN0IjsKKwkJCQkJCQlzdGF0dXMgPSAib2theSI7CisJCQkJCQkJcmVnID0gPDE+OworCQkJCQkJfTsKKworCQkJCQl9OworCQkJCX07CisJCQl9OworCQl9OworCisJCW92ZXJsYXkxMSB7CisJCQlmcmFnbWVudEAwIHsKKwkJCQl0YXJnZXQtcGF0aCA9ICIvdGVzdGNhc2UtZGF0YS9vdmVybGF5LW5vZGUvdGVzdC1idXMiOworCQkJCV9fb3ZlcmxheV9fIHsKKworCQkJCQkvKiBzdXBwcmVzcyBEVEMgd2FybmluZyAqLworCQkJCQkjYWRkcmVzcy1jZWxscyA9IDwxPjsKKwkJCQkJI3NpemUtY2VsbHMgPSA8MD47CisKKwkJCQkJdGVzdC1zZWxmdGVzdDExIHsKKwkJCQkJCWNvbXBhdGlibGUgPSAic2VsZnRlc3QiOworCQkJCQkJc3RhdHVzID0gIm9rYXkiOworCQkJCQkJcmVnID0gPDExPjsKKworCQkJCQkJI2FkZHJlc3MtY2VsbHMgPSA8MT47CisJCQkJCQkjc2l6ZS1jZWxscyA9IDwwPjsKKworCQkJCQkJdGVzdC1zZWxmdGVzdDExMSB7CisJCQkJCQkJY29tcGF0aWJsZSA9ICJzZWxmdGVzdCI7CisJCQkJCQkJc3RhdHVzID0gIm9rYXkiOworCQkJCQkJCXJlZyA9IDwxPjsKKwkJCQkJCX07CisKKwkJCQkJfTsKKwkJCQl9OworCQkJfTsKKwkJfTsKIAl9OwogfTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvb2YvdW5pdHRlc3QuYyBiL2RyaXZlcnMvb2YvdW5pdHRlc3QuYwppbmRleCA4NDQ4MzhlLi40MWE0YTEzIDEwMDY0NAotLS0gYS9kcml2ZXJzL29mL3VuaXR0ZXN0LmMKKysrIGIvZHJpdmVycy9vZi91bml0dGVzdC5jCkBAIC05NzgsNiArOTc4LDkgQEAKIAl9CiAKIAlkZXZfZGJnKGRldiwgIiVzIGZvciBub2RlIEAlc1xuIiwgX19mdW5jX18sIG5wLT5mdWxsX25hbWUpOworCisJb2ZfcGxhdGZvcm1fcG9wdWxhdGUobnAsIE5VTEwsIE5VTEwsICZwZGV2LT5kZXYpOworCiAJcmV0dXJuIDA7CiB9CiAKQEAgLTEzODUsNiArMTM4OCwzOSBAQAogCXNlbGZ0ZXN0KDEsICJvdmVybGF5IHRlc3QgJWQgcGFzc2VkXG4iLCA4KTsKIH0KIAorLyogdGVzdCBpbnNlcnRpb24gb2YgYSBidXMgd2l0aCBwYXJlbnQgZGV2aWNlcyAqLworc3RhdGljIHZvaWQgb2Zfc2VsZnRlc3Rfb3ZlcmxheV8xMCh2b2lkKQoreworCWludCByZXQ7CisJY2hhciAqY2hpbGRfcGF0aDsKKworCS8qIGRldmljZSBzaG91bGQgZGlzYWJsZSAqLworCXJldCA9IG9mX3NlbGZ0ZXN0X2FwcGx5X292ZXJsYXlfY2hlY2soMTAsIDEwLCAwLCAxKTsKKwlpZiAoc2VsZnRlc3QocmV0ID09IDAsICJvdmVybGF5IHRlc3QgJWQgZmFpbGVkOyBvdmVybGF5IGFwcGxpY2F0aW9uXG4iLCAxMCkpCisJCXJldHVybjsKKworCWNoaWxkX3BhdGggPSBrYXNwcmludGYoR0ZQX0tFUk5FTCwgIiVzL3Rlc3Qtc2VsZnRlc3QxMDEiLAorCQkJc2VsZnRlc3RfcGF0aCgxMCkpOworCWlmIChzZWxmdGVzdChjaGlsZF9wYXRoLCAib3ZlcmxheSB0ZXN0ICVkIGZhaWxlZDsga2FzcHJpbnRmXG4iLCAxMCkpCisJCXJldHVybjsKKworCXJldCA9IG9mX3BhdGhfcGxhdGZvcm1fZGV2aWNlX2V4aXN0cyhjaGlsZF9wYXRoKTsKKwlrZnJlZShjaGlsZF9wYXRoKTsKKwlpZiAoc2VsZnRlc3QocmV0LCAib3ZlcmxheSB0ZXN0ICVkIGZhaWxlZDsgbm8gY2hpbGQgZGV2aWNlXG4iLCAxMCkpCisJCXJldHVybjsKK30KKworLyogdGVzdCBpbnNlcnRpb24gb2YgYSBidXMgd2l0aCBwYXJlbnQgZGV2aWNlcyAoYW5kIHJldmVydCkgKi8KK3N0YXRpYyB2b2lkIG9mX3NlbGZ0ZXN0X292ZXJsYXlfMTEodm9pZCkKK3sKKwlpbnQgcmV0OworCisJLyogZGV2aWNlIHNob3VsZCBkaXNhYmxlICovCisJcmV0ID0gb2Zfc2VsZnRlc3RfYXBwbHlfcmV2ZXJ0X292ZXJsYXlfY2hlY2soMTEsIDExLCAwLCAxKTsKKwlpZiAoc2VsZnRlc3QocmV0ID09IDAsICJvdmVybGF5IHRlc3QgJWQgZmFpbGVkOyBvdmVybGF5IGFwcGxpY2F0aW9uXG4iLCAxMSkpCisJCXJldHVybjsKK30KKwogc3RhdGljIHZvaWQgX19pbml0IG9mX3NlbGZ0ZXN0X292ZXJsYXkodm9pZCkKIHsKIAlzdHJ1Y3QgZGV2aWNlX25vZGUgKmJ1c19ucCA9IE5VTEw7CkBAIC0xNDMzLDYgKzE0NjksOSBAQAogCW9mX3NlbGZ0ZXN0X292ZXJsYXlfNigpOwogCW9mX3NlbGZ0ZXN0X292ZXJsYXlfOCgpOwogCisJb2Zfc2VsZnRlc3Rfb3ZlcmxheV8xMCgpOworCW9mX3NlbGZ0ZXN0X292ZXJsYXlfMTEoKTsKKwogb3V0OgogCW9mX25vZGVfcHV0KGJ1c19ucCk7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3BhcmlzYy9sYmFfcGNpLmMgYi9kcml2ZXJzL3BhcmlzYy9sYmFfcGNpLmMKaW5kZXggMzdlNzFmZi4uZGNlYjlkZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9wYXJpc2MvbGJhX3BjaS5jCisrKyBiL2RyaXZlcnMvcGFyaXNjL2xiYV9wY2kuYwpAQCAtNjk0LDkgKzY5NCw4IEBACiAJCWludCBpOwogCQkvKiBQQ0ktUENJIEJyaWRnZSAqLwogCQlwY2lfcmVhZF9icmlkZ2VfYmFzZXMoYnVzKTsKLQkJZm9yIChpID0gUENJX0JSSURHRV9SRVNPVVJDRVM7IGkgPCBQQ0lfTlVNX1JFU09VUkNFUzsgaSsrKSB7Ci0JCQlwY2lfY2xhaW1fcmVzb3VyY2UoYnVzLT5zZWxmLCBpKTsKLQkJfQorCQlmb3IgKGkgPSBQQ0lfQlJJREdFX1JFU09VUkNFUzsgaSA8IFBDSV9OVU1fUkVTT1VSQ0VTOyBpKyspCisJCQlwY2lfY2xhaW1fYnJpZGdlX3Jlc291cmNlKGJ1cy0+c2VsZiwgaSk7CiAJfSBlbHNlIHsKIAkJLyogSG9zdC1QQ0kgQnJpZGdlICovCiAJCWludCBlcnI7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9idXMuYyBiL2RyaXZlcnMvcGNpL2J1cy5jCmluZGV4IDczYWVmNTEuLjkwZmEzYTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGNpL2J1cy5jCisrKyBiL2RyaXZlcnMvcGNpL2J1cy5jCkBAIC0yMCwxNyArMjAsMTYgQEAKIHZvaWQgcGNpX2FkZF9yZXNvdXJjZV9vZmZzZXQoc3RydWN0IGxpc3RfaGVhZCAqcmVzb3VyY2VzLCBzdHJ1Y3QgcmVzb3VyY2UgKnJlcywKIAkJCSAgICAgcmVzb3VyY2Vfc2l6ZV90IG9mZnNldCkKIHsKLQlzdHJ1Y3QgcGNpX2hvc3RfYnJpZGdlX3dpbmRvdyAqd2luZG93OworCXN0cnVjdCByZXNvdXJjZV9lbnRyeSAqZW50cnk7CiAKLQl3aW5kb3cgPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgcGNpX2hvc3RfYnJpZGdlX3dpbmRvdyksIEdGUF9LRVJORUwpOwotCWlmICghd2luZG93KSB7CisJZW50cnkgPSByZXNvdXJjZV9saXN0X2NyZWF0ZV9lbnRyeShyZXMsIDApOworCWlmICghZW50cnkpIHsKIAkJcHJpbnRrKEtFUk5fRVJSICJQQ0k6IGNhbid0IGFkZCBob3N0IGJyaWRnZSB3aW5kb3cgJXBSXG4iLCByZXMpOwogCQlyZXR1cm47CiAJfQogCi0Jd2luZG93LT5yZXMgPSByZXM7Ci0Jd2luZG93LT5vZmZzZXQgPSBvZmZzZXQ7Ci0JbGlzdF9hZGRfdGFpbCgmd2luZG93LT5saXN0LCByZXNvdXJjZXMpOworCWVudHJ5LT5vZmZzZXQgPSBvZmZzZXQ7CisJcmVzb3VyY2VfbGlzdF9hZGRfdGFpbChlbnRyeSwgcmVzb3VyY2VzKTsKIH0KIEVYUE9SVF9TWU1CT0wocGNpX2FkZF9yZXNvdXJjZV9vZmZzZXQpOwogCkBAIC00MiwxMiArNDEsNyBAQAogCiB2b2lkIHBjaV9mcmVlX3Jlc291cmNlX2xpc3Qoc3RydWN0IGxpc3RfaGVhZCAqcmVzb3VyY2VzKQogewotCXN0cnVjdCBwY2lfaG9zdF9icmlkZ2Vfd2luZG93ICp3aW5kb3csICp0bXA7Ci0KLQlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUod2luZG93LCB0bXAsIHJlc291cmNlcywgbGlzdCkgewotCQlsaXN0X2RlbCgmd2luZG93LT5saXN0KTsKLQkJa2ZyZWUod2luZG93KTsKLQl9CisJcmVzb3VyY2VfbGlzdF9mcmVlKHJlc291cmNlcyk7CiB9CiBFWFBPUlRfU1lNQk9MKHBjaV9mcmVlX3Jlc291cmNlX2xpc3QpOwogCkBAIC0yMjgsNiArMjIyLDQ5IEBACiB9CiBFWFBPUlRfU1lNQk9MKHBjaV9idXNfYWxsb2NfcmVzb3VyY2UpOwogCisvKgorICogVGhlIEBpZHggcmVzb3VyY2Ugb2YgQGRldiBzaG91bGQgYmUgYSBQQ0ktUENJIGJyaWRnZSB3aW5kb3cuICBJZiB0aGlzCisgKiByZXNvdXJjZSBmaXRzIGluc2lkZSBhIHdpbmRvdyBvZiBhbiB1cHN0cmVhbSBicmlkZ2UsIGRvIG5vdGhpbmcuICBJZiBpdAorICogb3ZlcmxhcHMgYW4gdXBzdHJlYW0gd2luZG93IGJ1dCBleHRlbmRzIG91dHNpZGUgaXQsIGNsaXAgdGhlIHJlc291cmNlIHNvCisgKiBpdCBmaXRzIGNvbXBsZXRlbHkgaW5zaWRlLgorICovCitib29sIHBjaV9idXNfY2xpcF9yZXNvdXJjZShzdHJ1Y3QgcGNpX2RldiAqZGV2LCBpbnQgaWR4KQoreworCXN0cnVjdCBwY2lfYnVzICpidXMgPSBkZXYtPmJ1czsKKwlzdHJ1Y3QgcmVzb3VyY2UgKnJlcyA9ICZkZXYtPnJlc291cmNlW2lkeF07CisJc3RydWN0IHJlc291cmNlIG9yaWdfcmVzID0gKnJlczsKKwlzdHJ1Y3QgcmVzb3VyY2UgKnI7CisJaW50IGk7CisKKwlwY2lfYnVzX2Zvcl9lYWNoX3Jlc291cmNlKGJ1cywgciwgaSkgeworCQlyZXNvdXJjZV9zaXplX3Qgc3RhcnQsIGVuZDsKKworCQlpZiAoIXIpCisJCQljb250aW51ZTsKKworCQlpZiAocmVzb3VyY2VfdHlwZShyZXMpICE9IHJlc291cmNlX3R5cGUocikpCisJCQljb250aW51ZTsKKworCQlzdGFydCA9IG1heChyLT5zdGFydCwgcmVzLT5zdGFydCk7CisJCWVuZCA9IG1pbihyLT5lbmQsIHJlcy0+ZW5kKTsKKworCQlpZiAoc3RhcnQgPiBlbmQpCisJCQljb250aW51ZTsJLyogbm8gb3ZlcmxhcCAqLworCisJCWlmIChyZXMtPnN0YXJ0ID09IHN0YXJ0ICYmIHJlcy0+ZW5kID09IGVuZCkKKwkJCXJldHVybiBmYWxzZTsJLyogbm8gY2hhbmdlICovCisKKwkJcmVzLT5zdGFydCA9IHN0YXJ0OworCQlyZXMtPmVuZCA9IGVuZDsKKwkJZGV2X3ByaW50ayhLRVJOX0RFQlVHLCAmZGV2LT5kZXYsICIlcFIgY2xpcHBlZCB0byAlcFJcbiIsCisJCQkJICZvcmlnX3JlcywgcmVzKTsKKworCQlyZXR1cm4gdHJ1ZTsKKwl9CisKKwlyZXR1cm4gZmFsc2U7Cit9CisKIHZvaWQgX193ZWFrIHBjaWJpb3NfcmVzb3VyY2Vfc3VydmV5X2J1cyhzdHJ1Y3QgcGNpX2J1cyAqYnVzKSB7IH0KIAogLyoqCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9ob3N0LWJyaWRnZS5jIGIvZHJpdmVycy9wY2kvaG9zdC1icmlkZ2UuYwppbmRleCAwZTVmM2M5Li4zOWIyZGJlIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BjaS9ob3N0LWJyaWRnZS5jCisrKyBiL2RyaXZlcnMvcGNpL2hvc3QtYnJpZGdlLmMKQEAgLTM1LDEwICszNSwxMCBAQAogCQkJICAgICBzdHJ1Y3QgcmVzb3VyY2UgKnJlcykKIHsKIAlzdHJ1Y3QgcGNpX2hvc3RfYnJpZGdlICpicmlkZ2UgPSBmaW5kX3BjaV9ob3N0X2JyaWRnZShidXMpOwotCXN0cnVjdCBwY2lfaG9zdF9icmlkZ2Vfd2luZG93ICp3aW5kb3c7CisJc3RydWN0IHJlc291cmNlX2VudHJ5ICp3aW5kb3c7CiAJcmVzb3VyY2Vfc2l6ZV90IG9mZnNldCA9IDA7CiAKLQlsaXN0X2Zvcl9lYWNoX2VudHJ5KHdpbmRvdywgJmJyaWRnZS0+d2luZG93cywgbGlzdCkgeworCXJlc291cmNlX2xpc3RfZm9yX2VhY2hfZW50cnkod2luZG93LCAmYnJpZGdlLT53aW5kb3dzKSB7CiAJCWlmIChyZXNvdXJjZV9jb250YWlucyh3aW5kb3ctPnJlcywgcmVzKSkgewogCQkJb2Zmc2V0ID0gd2luZG93LT5vZmZzZXQ7CiAJCQlicmVhazsKQEAgLTYwLDEwICs2MCwxMCBAQAogCQkJICAgICBzdHJ1Y3QgcGNpX2J1c19yZWdpb24gKnJlZ2lvbikKIHsKIAlzdHJ1Y3QgcGNpX2hvc3RfYnJpZGdlICpicmlkZ2UgPSBmaW5kX3BjaV9ob3N0X2JyaWRnZShidXMpOwotCXN0cnVjdCBwY2lfaG9zdF9icmlkZ2Vfd2luZG93ICp3aW5kb3c7CisJc3RydWN0IHJlc291cmNlX2VudHJ5ICp3aW5kb3c7CiAJcmVzb3VyY2Vfc2l6ZV90IG9mZnNldCA9IDA7CiAKLQlsaXN0X2Zvcl9lYWNoX2VudHJ5KHdpbmRvdywgJmJyaWRnZS0+d2luZG93cywgbGlzdCkgeworCXJlc291cmNlX2xpc3RfZm9yX2VhY2hfZW50cnkod2luZG93LCAmYnJpZGdlLT53aW5kb3dzKSB7CiAJCXN0cnVjdCBwY2lfYnVzX3JlZ2lvbiBidXNfcmVnaW9uOwogCiAJCWlmIChyZXNvdXJjZV90eXBlKHJlcykgIT0gcmVzb3VyY2VfdHlwZSh3aW5kb3ctPnJlcykpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9ob3N0L3BjaS1ob3N0LWdlbmVyaWMuYyBiL2RyaXZlcnMvcGNpL2hvc3QvcGNpLWhvc3QtZ2VuZXJpYy5jCmluZGV4IDZlYjFhYTcuLmFlZTNjNjIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGNpL2hvc3QvcGNpLWhvc3QtZ2VuZXJpYy5jCisrKyBiL2RyaXZlcnMvcGNpL2hvc3QvcGNpLWhvc3QtZ2VuZXJpYy5jCkBAIC0xNDksMTQgKzE0OSwxNCBAQAogCXN0cnVjdCBkZXZpY2UgKmRldiA9IHBjaS0+aG9zdC5kZXYucGFyZW50OwogCXN0cnVjdCBkZXZpY2Vfbm9kZSAqbnAgPSBkZXYtPm9mX25vZGU7CiAJcmVzb3VyY2Vfc2l6ZV90IGlvYmFzZTsKLQlzdHJ1Y3QgcGNpX2hvc3RfYnJpZGdlX3dpbmRvdyAqd2luOworCXN0cnVjdCByZXNvdXJjZV9lbnRyeSAqd2luOwogCiAJZXJyID0gb2ZfcGNpX2dldF9ob3N0X2JyaWRnZV9yZXNvdXJjZXMobnAsIDAsIDB4ZmYsICZwY2ktPnJlc291cmNlcywKIAkJCQkJICAgICAgICZpb2Jhc2UpOwogCWlmIChlcnIpCiAJCXJldHVybiBlcnI7CiAKLQlsaXN0X2Zvcl9lYWNoX2VudHJ5KHdpbiwgJnBjaS0+cmVzb3VyY2VzLCBsaXN0KSB7CisJcmVzb3VyY2VfbGlzdF9mb3JfZWFjaF9lbnRyeSh3aW4sICZwY2ktPnJlc291cmNlcykgewogCQlzdHJ1Y3QgcmVzb3VyY2UgKnBhcmVudCwgKnJlcyA9IHdpbi0+cmVzOwogCiAJCXN3aXRjaCAocmVzb3VyY2VfdHlwZShyZXMpKSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9ob3N0L3BjaS14Z2VuZS5jIGIvZHJpdmVycy9wY2kvaG9zdC9wY2kteGdlbmUuYwppbmRleCBiMWQwNTk2Li5hNzA0MjU3IDEwMDY0NAotLS0gYS9kcml2ZXJzL3BjaS9ob3N0L3BjaS14Z2VuZS5jCisrKyBiL2RyaXZlcnMvcGNpL2hvc3QvcGNpLXhnZW5lLmMKQEAgLTQwMSwxMSArNDAxLDExIEBACiAJCQkJIHN0cnVjdCBsaXN0X2hlYWQgKnJlcywKIAkJCQkgcmVzb3VyY2Vfc2l6ZV90IGlvX2Jhc2UpCiB7Ci0Jc3RydWN0IHBjaV9ob3N0X2JyaWRnZV93aW5kb3cgKndpbmRvdzsKKwlzdHJ1Y3QgcmVzb3VyY2VfZW50cnkgKndpbmRvdzsKIAlzdHJ1Y3QgZGV2aWNlICpkZXYgPSBwb3J0LT5kZXY7CiAJaW50IHJldDsKIAotCWxpc3RfZm9yX2VhY2hfZW50cnkod2luZG93LCByZXMsIGxpc3QpIHsKKwlyZXNvdXJjZV9saXN0X2Zvcl9lYWNoX2VudHJ5KHdpbmRvdywgcmVzKSB7CiAJCXN0cnVjdCByZXNvdXJjZSAqcmVzID0gd2luZG93LT5yZXM7CiAJCXU2NCByZXN0eXBlID0gcmVzb3VyY2VfdHlwZShyZXMpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9ob3N0L3BjaWUtZGVzaWdud2FyZS5jIGIvZHJpdmVycy9wY2kvaG9zdC9wY2llLWRlc2lnbndhcmUuYwppbmRleCBkZjc4MWNkLi4xN2NhOTg2IDEwMDY0NAotLS0gYS9kcml2ZXJzL3BjaS9ob3N0L3BjaWUtZGVzaWdud2FyZS5jCisrKyBiL2RyaXZlcnMvcGNpL2hvc3QvcGNpZS1kZXNpZ253YXJlLmMKQEAgLTI4Myw2ICsyODMsOSBAQAogCXN0cnVjdCBtc2lfbXNnIG1zZzsKIAlzdHJ1Y3QgcGNpZV9wb3J0ICpwcCA9IHN5c190b19wY2llKHBkZXYtPmJ1cy0+c3lzZGF0YSk7CiAKKwlpZiAoZGVzYy0+bXNpX2F0dHJpYi5pc19tc2l4KQorCQlyZXR1cm4gLUVJTlZBTDsKKwogCWlycSA9IGFzc2lnbl9pcnEoMSwgZGVzYywgJnBvcyk7CiAJaWYgKGlycSA8IDApCiAJCXJldHVybiBpcnE7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9ob3N0L3BjaWUteGlsaW54LmMgYi9kcml2ZXJzL3BjaS9ob3N0L3BjaWUteGlsaW54LmMKaW5kZXggZWYzZWJhZi4uNjAxMjYxZGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGNpL2hvc3QvcGNpZS14aWxpbnguYworKysgYi9kcml2ZXJzL3BjaS9ob3N0L3BjaWUteGlsaW54LmMKQEAgLTczNyw3ICs3MzcsNyBAQAogCXJlc291cmNlX3NpemVfdCBvZmZzZXQ7CiAJc3RydWN0IG9mX3BjaV9yYW5nZV9wYXJzZXIgcGFyc2VyOwogCXN0cnVjdCBvZl9wY2lfcmFuZ2UgcmFuZ2U7Ci0Jc3RydWN0IHBjaV9ob3N0X2JyaWRnZV93aW5kb3cgKndpbjsKKwlzdHJ1Y3QgcmVzb3VyY2VfZW50cnkgKndpbjsKIAlpbnQgZXJyID0gMCwgbWVtX3Jlc25vID0gMDsKIAogCS8qIEdldCB0aGUgcmFuZ2VzICovCkBAIC04MDcsNyArODA3LDcgQEAKIAogZnJlZV9yZXNvdXJjZXM6CiAJcmVsZWFzZV9jaGlsZF9yZXNvdXJjZXMoJmlvbWVtX3Jlc291cmNlKTsKLQlsaXN0X2Zvcl9lYWNoX2VudHJ5KHdpbiwgJnBvcnQtPnJlc291cmNlcywgbGlzdCkKKwlyZXNvdXJjZV9saXN0X2Zvcl9lYWNoX2VudHJ5KHdpbiwgJnBvcnQtPnJlc291cmNlcykKIAkJZGV2bV9rZnJlZShkZXYsIHdpbi0+cmVzKTsKIAlwY2lfZnJlZV9yZXNvdXJjZV9saXN0KCZwb3J0LT5yZXNvdXJjZXMpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9ob3RwbHVnL3NnaV9ob3RwbHVnLmMgYi9kcml2ZXJzL3BjaS9ob3RwbHVnL3NnaV9ob3RwbHVnLmMKaW5kZXggYmFkYTIwOTkuLmMzMmZiNzggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGNpL2hvdHBsdWcvc2dpX2hvdHBsdWcuYworKysgYi9kcml2ZXJzL3BjaS9ob3RwbHVnL3NnaV9ob3RwbHVnLmMKQEAgLTQ3NSw3ICs0NzUsNyBAQAogCXN0cnVjdCBzbG90ICpzbG90ID0gYnNzX2hvdHBsdWdfc2xvdC0+cHJpdmF0ZTsKIAlzdHJ1Y3QgcGNpX2RldiAqZGV2LCAqdGVtcDsKIAlpbnQgcmM7Ci0JYWNwaV9vd25lcl9pZCBzc2R0X2lkID0gMDsKKwlhY3BpX2hhbmRsZSBzc2R0X2hkbCA9IE5VTEw7CiAKIAkvKiBBY3F1aXJlIHVwZGF0ZSBhY2Nlc3MgdG8gdGhlIGJ1cyAqLwogCW11dGV4X2xvY2soJnNuX2hvdHBsdWdfbXV0ZXgpOwpAQCAtNTIyLDcgKzUyMiw3IEBACiAJCQlpZiAoQUNQSV9TVUNDRVNTKHJldCkgJiYKIAkJCSAgICAoYWRyPj4xNikgPT0gKHNsb3QtPmRldmljZV9udW0gKyAxKSkgewogCQkJCS8qIHJldGFpbiB0aGUgb3duZXIgaWQgKi8KLQkJCQlhY3BpX2dldF9pZChjaGFuZGxlLCAmc3NkdF9pZCk7CisJCQkJc3NkdF9oZGwgPSBjaGFuZGxlOwogCiAJCQkJcmV0ID0gYWNwaV9idXNfZ2V0X2RldmljZShjaGFuZGxlLAogCQkJCQkJCSAgJmRldmljZSk7CkBAIC01NDcsMTIgKzU0NywxMyBAQAogCXBjaV91bmxvY2tfcmVzY2FuX3JlbW92ZSgpOwogCiAJLyogUmVtb3ZlIHRoZSBTU0RUIGZvciB0aGUgc2xvdCBmcm9tIHRoZSBBQ1BJIG5hbWVzcGFjZSAqLwotCWlmIChTTl9BQ1BJX0JBU0VfU1VQUE9SVCgpICYmIHNzZHRfaWQpIHsKKwlpZiAoU05fQUNQSV9CQVNFX1NVUFBPUlQoKSAmJiBzc2R0X2hkbCkgewogCQlhY3BpX3N0YXR1cyByZXQ7Ci0JCXJldCA9IGFjcGlfdW5sb2FkX3RhYmxlX2lkKHNzZHRfaWQpOworCQlyZXQgPSBhY3BpX3VubG9hZF9wYXJlbnRfdGFibGUoc3NkdF9oZGwpOwogCQlpZiAoQUNQSV9GQUlMVVJFKHJldCkpIHsKLQkJCXByaW50ayhLRVJOX0VSUiAiJXM6IGFjcGlfdW5sb2FkX3RhYmxlX2lkIGZhaWxlZCAoMHgleCkgZm9yIGlkICVkXG4iLAotCQkJICAgICAgIF9fZnVuY19fLCByZXQsIHNzZHRfaWQpOworCQkJYWNwaV9oYW5kbGVfZXJyKHNzZHRfaGRsLAorCQkJCQkiJXM6IGFjcGlfdW5sb2FkX3BhcmVudF90YWJsZSBmYWlsZWQgKDB4JXgpXG4iLAorCQkJCQlfX2Z1bmNfXywgcmV0KTsKIAkJCS8qIHRyeSB0byBjb250aW51ZSBvbiAqLwogCQl9CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9wY2kvcGNpLWFjcGkuYyBiL2RyaXZlcnMvcGNpL3BjaS1hY3BpLmMKaW5kZXggMzU0MjE1MC4uNDg5MDYzOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9wY2kvcGNpLWFjcGkuYworKysgYi9kcml2ZXJzL3BjaS9wY2ktYWNwaS5jCkBAIC01MDEsMTIgKzUwMSwyOSBAQAogCXJldHVybiAwOwogfQogCitzdGF0aWMgYm9vbCBhY3BpX3BjaV9uZWVkX3Jlc3VtZShzdHJ1Y3QgcGNpX2RldiAqZGV2KQoreworCXN0cnVjdCBhY3BpX2RldmljZSAqYWRldiA9IEFDUElfQ09NUEFOSU9OKCZkZXYtPmRldik7CisKKwlpZiAoIWFkZXYgfHwgIWFjcGlfZGV2aWNlX3Bvd2VyX21hbmFnZWFibGUoYWRldikpCisJCXJldHVybiBmYWxzZTsKKworCWlmIChkZXZpY2VfbWF5X3dha2V1cCgmZGV2LT5kZXYpICE9ICEhYWRldi0+d2FrZXVwLnByZXBhcmVfY291bnQpCisJCXJldHVybiB0cnVlOworCisJaWYgKGFjcGlfdGFyZ2V0X3N5c3RlbV9zdGF0ZSgpID09IEFDUElfU1RBVEVfUzApCisJCXJldHVybiBmYWxzZTsKKworCXJldHVybiAhIWFkZXYtPnBvd2VyLmZsYWdzLmRzd19wcmVzZW50OworfQorCiBzdGF0aWMgc3RydWN0IHBjaV9wbGF0Zm9ybV9wbV9vcHMgYWNwaV9wY2lfcGxhdGZvcm1fcG0gPSB7CiAJLmlzX21hbmFnZWFibGUgPSBhY3BpX3BjaV9wb3dlcl9tYW5hZ2VhYmxlLAogCS5zZXRfc3RhdGUgPSBhY3BpX3BjaV9zZXRfcG93ZXJfc3RhdGUsCiAJLmNob29zZV9zdGF0ZSA9IGFjcGlfcGNpX2Nob29zZV9zdGF0ZSwKIAkuc2xlZXBfd2FrZSA9IGFjcGlfcGNpX3NsZWVwX3dha2UsCiAJLnJ1bl93YWtlID0gYWNwaV9wY2lfcnVuX3dha2UsCisJLm5lZWRfcmVzdW1lID0gYWNwaV9wY2lfbmVlZF9yZXN1bWUsCiB9OwogCiB2b2lkIGFjcGlfcGNpX2FkZF9idXMoc3RydWN0IHBjaV9idXMgKmJ1cykKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGNpL3BjaS1kcml2ZXIuYyBiL2RyaXZlcnMvcGNpL3BjaS1kcml2ZXIuYwppbmRleCA4ODdlNmJkLi43NDEwMjNlIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BjaS9wY2ktZHJpdmVyLmMKKysrIGIvZHJpdmVycy9wY2kvcGNpLWRyaXZlci5jCkBAIC02NTMsNyArNjUzLDYgQEAKIHN0YXRpYyBpbnQgcGNpX3BtX3ByZXBhcmUoc3RydWN0IGRldmljZSAqZGV2KQogewogCXN0cnVjdCBkZXZpY2VfZHJpdmVyICpkcnYgPSBkZXYtPmRyaXZlcjsKLQlpbnQgZXJyb3IgPSAwOwogCiAJLyoKIAkgKiBEZXZpY2VzIGhhdmluZyBwb3dlci5pZ25vcmVfY2hpbGRyZW4gc2V0IG1heSBzdGlsbCBiZSBuZWNlc3NhcnkgZm9yCkBAIC02NjIsMTAgKzY2MSwxMiBAQAogCWlmIChkZXYtPnBvd2VyLmlnbm9yZV9jaGlsZHJlbikKIAkJcG1fcnVudGltZV9yZXN1bWUoZGV2KTsKIAotCWlmIChkcnYgJiYgZHJ2LT5wbSAmJiBkcnYtPnBtLT5wcmVwYXJlKQotCQllcnJvciA9IGRydi0+cG0tPnByZXBhcmUoZGV2KTsKLQotCXJldHVybiBlcnJvcjsKKwlpZiAoZHJ2ICYmIGRydi0+cG0gJiYgZHJ2LT5wbS0+cHJlcGFyZSkgeworCQlpbnQgZXJyb3IgPSBkcnYtPnBtLT5wcmVwYXJlKGRldik7CisJCWlmIChlcnJvcikKKwkJCXJldHVybiBlcnJvcjsKKwl9CisJcmV0dXJuIHBjaV9kZXZfa2VlcF9zdXNwZW5kZWQodG9fcGNpX2RldihkZXYpKTsKIH0KIAogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9wY2kuYyBiL2RyaXZlcnMvcGNpL3BjaS5jCmluZGV4IGNhYjA1ZjMuLjhjZjZiODU5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3BjaS9wY2kuYworKysgYi9kcml2ZXJzL3BjaS9wY2kuYwpAQCAtNTIxLDYgKzUyMSwxMSBAQAogCQkJcGNpX3BsYXRmb3JtX3BtLT5ydW5fd2FrZShkZXYsIGVuYWJsZSkgOiAtRU5PREVWOwogfQogCitzdGF0aWMgaW5saW5lIGJvb2wgcGxhdGZvcm1fcGNpX25lZWRfcmVzdW1lKHN0cnVjdCBwY2lfZGV2ICpkZXYpCit7CisJcmV0dXJuIHBjaV9wbGF0Zm9ybV9wbSA/IHBjaV9wbGF0Zm9ybV9wbS0+bmVlZF9yZXN1bWUoZGV2KSA6IGZhbHNlOworfQorCiAvKioKICAqIHBjaV9yYXdfc2V0X3Bvd2VyX3N0YXRlIC0gVXNlIFBDSSBQTSByZWdpc3RlcnMgdG8gc2V0IHRoZSBwb3dlciBzdGF0ZSBvZgogICogICAgICAgICAgICAgICAgICAgICAgICAgICBnaXZlbiBQQ0kgZGV2aWNlCkBAIC0xOTk5LDYgKzIwMDQsMjcgQEAKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKHBjaV9kZXZfcnVuX3dha2UpOwogCisvKioKKyAqIHBjaV9kZXZfa2VlcF9zdXNwZW5kZWQgLSBDaGVjayBpZiB0aGUgZGV2aWNlIGNhbiBzdGF5IGluIHRoZSBzdXNwZW5kZWQgc3RhdGUuCisgKiBAcGNpX2RldjogRGV2aWNlIHRvIGNoZWNrLgorICoKKyAqIFJldHVybiAndHJ1ZScgaWYgdGhlIGRldmljZSBpcyBydW50aW1lLXN1c3BlbmRlZCwgaXQgZG9lc24ndCBoYXZlIHRvIGJlCisgKiByZWNvbmZpZ3VyZWQgZHVlIHRvIHdha2V1cCBzZXR0aW5ncyBkaWZmZXJlbmNlIGJldHdlZW4gc3lzdGVtIGFuZCBydW50aW1lCisgKiBzdXNwZW5kIGFuZCB0aGUgY3VycmVudCBwb3dlciBzdGF0ZSBvZiBpdCBpcyBzdWl0YWJsZSBmb3IgdGhlIHVwY29taW5nCisgKiAoc3lzdGVtKSB0cmFuc2l0aW9uLgorICovCitib29sIHBjaV9kZXZfa2VlcF9zdXNwZW5kZWQoc3RydWN0IHBjaV9kZXYgKnBjaV9kZXYpCit7CisJc3RydWN0IGRldmljZSAqZGV2ID0gJnBjaV9kZXYtPmRldjsKKworCWlmICghcG1fcnVudGltZV9zdXNwZW5kZWQoZGV2KQorCSAgICB8fCAoZGV2aWNlX2Nhbl93YWtldXAoZGV2KSAmJiAhZGV2aWNlX21heV93YWtldXAoZGV2KSkKKwkgICAgfHwgcGxhdGZvcm1fcGNpX25lZWRfcmVzdW1lKHBjaV9kZXYpKQorCQlyZXR1cm4gZmFsc2U7CisKKwlyZXR1cm4gcGNpX3RhcmdldF9zdGF0ZShwY2lfZGV2KSA9PSBwY2lfZGV2LT5jdXJyZW50X3N0YXRlOworfQorCiB2b2lkIHBjaV9jb25maWdfcG1fcnVudGltZV9nZXQoc3RydWN0IHBjaV9kZXYgKnBkZXYpCiB7CiAJc3RydWN0IGRldmljZSAqZGV2ID0gJnBkZXYtPmRldjsKQEAgLTMyNzEsNyArMzI5Nyw4IEBACiB7CiAJc3RydWN0IHBjaV9kZXYgKnBkZXY7CiAKLQlpZiAocGNpX2lzX3Jvb3RfYnVzKGRldi0+YnVzKSB8fCBkZXYtPnN1Ym9yZGluYXRlIHx8ICFkZXYtPmJ1cy0+c2VsZikKKwlpZiAocGNpX2lzX3Jvb3RfYnVzKGRldi0+YnVzKSB8fCBkZXYtPnN1Ym9yZGluYXRlIHx8CisJICAgICFkZXYtPmJ1cy0+c2VsZiB8fCBkZXYtPmRldl9mbGFncyAmIFBDSV9ERVZfRkxBR1NfTk9fQlVTX1JFU0VUKQogCQlyZXR1cm4gLUVOT1RUWTsKIAogCWxpc3RfZm9yX2VhY2hfZW50cnkocGRldiwgJmRldi0+YnVzLT5kZXZpY2VzLCBidXNfbGlzdCkKQEAgLTMzMDUsNyArMzMzMiw4IEBACiB7CiAJc3RydWN0IHBjaV9kZXYgKnBkZXY7CiAKLQlpZiAoZGV2LT5zdWJvcmRpbmF0ZSB8fCAhZGV2LT5zbG90KQorCWlmIChkZXYtPnN1Ym9yZGluYXRlIHx8ICFkZXYtPnNsb3QgfHwKKwkgICAgZGV2LT5kZXZfZmxhZ3MgJiBQQ0lfREVWX0ZMQUdTX05PX0JVU19SRVNFVCkKIAkJcmV0dXJuIC1FTk9UVFk7CiAKIAlsaXN0X2Zvcl9lYWNoX2VudHJ5KHBkZXYsICZkZXYtPmJ1cy0+ZGV2aWNlcywgYnVzX2xpc3QpCkBAIC0zNTU3LDYgKzM1ODUsMjAgQEAKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKHBjaV90cnlfcmVzZXRfZnVuY3Rpb24pOwogCisvKiBEbyBhbnkgZGV2aWNlcyBvbiBvciBiZWxvdyB0aGlzIGJ1cyBwcmV2ZW50IGEgYnVzIHJlc2V0PyAqLworc3RhdGljIGJvb2wgcGNpX2J1c19yZXNldGFibGUoc3RydWN0IHBjaV9idXMgKmJ1cykKK3sKKwlzdHJ1Y3QgcGNpX2RldiAqZGV2OworCisJbGlzdF9mb3JfZWFjaF9lbnRyeShkZXYsICZidXMtPmRldmljZXMsIGJ1c19saXN0KSB7CisJCWlmIChkZXYtPmRldl9mbGFncyAmIFBDSV9ERVZfRkxBR1NfTk9fQlVTX1JFU0VUIHx8CisJCSAgICAoZGV2LT5zdWJvcmRpbmF0ZSAmJiAhcGNpX2J1c19yZXNldGFibGUoZGV2LT5zdWJvcmRpbmF0ZSkpKQorCQkJcmV0dXJuIGZhbHNlOworCX0KKworCXJldHVybiB0cnVlOworfQorCiAvKiBMb2NrIGRldmljZXMgZnJvbSB0aGUgdG9wIG9mIHRoZSB0cmVlIGRvd24gKi8KIHN0YXRpYyB2b2lkIHBjaV9idXNfbG9jayhzdHJ1Y3QgcGNpX2J1cyAqYnVzKQogewpAQCAtMzYwNyw2ICszNjQ5LDIyIEBACiAJcmV0dXJuIDA7CiB9CiAKKy8qIERvIGFueSBkZXZpY2VzIG9uIG9yIGJlbG93IHRoaXMgc2xvdCBwcmV2ZW50IGEgYnVzIHJlc2V0PyAqLworc3RhdGljIGJvb2wgcGNpX3Nsb3RfcmVzZXRhYmxlKHN0cnVjdCBwY2lfc2xvdCAqc2xvdCkKK3sKKwlzdHJ1Y3QgcGNpX2RldiAqZGV2OworCisJbGlzdF9mb3JfZWFjaF9lbnRyeShkZXYsICZzbG90LT5idXMtPmRldmljZXMsIGJ1c19saXN0KSB7CisJCWlmICghZGV2LT5zbG90IHx8IGRldi0+c2xvdCAhPSBzbG90KQorCQkJY29udGludWU7CisJCWlmIChkZXYtPmRldl9mbGFncyAmIFBDSV9ERVZfRkxBR1NfTk9fQlVTX1JFU0VUIHx8CisJCSAgICAoZGV2LT5zdWJvcmRpbmF0ZSAmJiAhcGNpX2J1c19yZXNldGFibGUoZGV2LT5zdWJvcmRpbmF0ZSkpKQorCQkJcmV0dXJuIGZhbHNlOworCX0KKworCXJldHVybiB0cnVlOworfQorCiAvKiBMb2NrIGRldmljZXMgZnJvbSB0aGUgdG9wIG9mIHRoZSB0cmVlIGRvd24gKi8KIHN0YXRpYyB2b2lkIHBjaV9zbG90X2xvY2soc3RydWN0IHBjaV9zbG90ICpzbG90KQogewpAQCAtMzcyOCw3ICszNzg2LDcgQEAKIHsKIAlpbnQgcmM7CiAKLQlpZiAoIXNsb3QpCisJaWYgKCFzbG90IHx8ICFwY2lfc2xvdF9yZXNldGFibGUoc2xvdCkpCiAJCXJldHVybiAtRU5PVFRZOwogCiAJaWYgKCFwcm9iZSkKQEAgLTM4MjAsNyArMzg3OCw3IEBACiAKIHN0YXRpYyBpbnQgcGNpX2J1c19yZXNldChzdHJ1Y3QgcGNpX2J1cyAqYnVzLCBpbnQgcHJvYmUpCiB7Ci0JaWYgKCFidXMtPnNlbGYpCisJaWYgKCFidXMtPnNlbGYgfHwgIXBjaV9idXNfcmVzZXRhYmxlKGJ1cykpCiAJCXJldHVybiAtRU5PVFRZOwogCiAJaWYgKHByb2JlKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9wY2kvcGNpLmggYi9kcml2ZXJzL3BjaS9wY2kuaAppbmRleCA4YWZmMjlhLi40MDkxZjgyIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BjaS9wY2kuaAorKysgYi9kcml2ZXJzL3BjaS9wY2kuaApAQCAtNTAsNiArNTAsMTAgQEAKICAqCQlmb3IgZ2l2ZW4gZGV2aWNlICh0aGUgZGV2aWNlJ3Mgd2FrZS11cCBjYXBhYmlsaXR5IGhhcyB0byBiZQogICoJCWVuYWJsZWQgYnkgQHNsZWVwX3dha2UgZm9yIHRoaXMgZmVhdHVyZSB0byB3b3JrKQogICoKKyAqIEBuZWVkX3Jlc3VtZTogcmV0dXJucyAndHJ1ZScgaWYgdGhlIGdpdmVuIGRldmljZSAod2hpY2ggaXMgY3VycmVudGx5CisgKgkJc3VzcGVuZGVkKSBuZWVkcyB0byBiZSByZXN1bWVkIHRvIGJlIGNvbmZpZ3VyZWQgZm9yIHN5c3RlbQorICoJCXdha2V1cC4KKyAqCiAgKiBJZiBnaXZlbiBwbGF0Zm9ybSBpcyBnZW5lcmFsbHkgY2FwYWJsZSBvZiBwb3dlciBtYW5hZ2luZyBQQ0kgZGV2aWNlcywgYWxsIG9mCiAgKiB0aGVzZSBjYWxsYmFja3MgYXJlIG1hbmRhdG9yeS4KICAqLwpAQCAtNTksNiArNjMsNyBAQAogCXBjaV9wb3dlcl90ICgqY2hvb3NlX3N0YXRlKShzdHJ1Y3QgcGNpX2RldiAqZGV2KTsKIAlpbnQgKCpzbGVlcF93YWtlKShzdHJ1Y3QgcGNpX2RldiAqZGV2LCBib29sIGVuYWJsZSk7CiAJaW50ICgqcnVuX3dha2UpKHN0cnVjdCBwY2lfZGV2ICpkZXYsIGJvb2wgZW5hYmxlKTsKKwlib29sICgqbmVlZF9yZXN1bWUpKHN0cnVjdCBwY2lfZGV2ICpkZXYpOwogfTsKIAogaW50IHBjaV9zZXRfcGxhdGZvcm1fcG0oc3RydWN0IHBjaV9wbGF0Zm9ybV9wbV9vcHMgKm9wcyk7CkBAIC02Nyw2ICs3Miw3IEBACiB2b2lkIHBjaV9kaXNhYmxlX2VuYWJsZWRfZGV2aWNlKHN0cnVjdCBwY2lfZGV2ICpkZXYpOwogaW50IHBjaV9maW5pc2hfcnVudGltZV9zdXNwZW5kKHN0cnVjdCBwY2lfZGV2ICpkZXYpOwogaW50IF9fcGNpX3BtZV93YWtldXAoc3RydWN0IHBjaV9kZXYgKmRldiwgdm9pZCAqaWduKTsKK2Jvb2wgcGNpX2Rldl9rZWVwX3N1c3BlbmRlZChzdHJ1Y3QgcGNpX2RldiAqZGV2KTsKIHZvaWQgcGNpX2NvbmZpZ19wbV9ydW50aW1lX2dldChzdHJ1Y3QgcGNpX2RldiAqZGV2KTsKIHZvaWQgcGNpX2NvbmZpZ19wbV9ydW50aW1lX3B1dChzdHJ1Y3QgcGNpX2RldiAqZGV2KTsKIHZvaWQgcGNpX3BtX2luaXQoc3RydWN0IHBjaV9kZXYgKmRldik7CkBAIC0yMDgsNiArMjE0LDcgQEAKIHZvaWQgX19wY2lfYnVzX2Fzc2lnbl9yZXNvdXJjZXMoY29uc3Qgc3RydWN0IHBjaV9idXMgKmJ1cywKIAkJCQlzdHJ1Y3QgbGlzdF9oZWFkICpyZWFsbG9jX2hlYWQsCiAJCQkJc3RydWN0IGxpc3RfaGVhZCAqZmFpbF9oZWFkKTsKK2Jvb2wgcGNpX2J1c19jbGlwX3Jlc291cmNlKHN0cnVjdCBwY2lfZGV2ICpkZXYsIGludCBpZHgpOwogCiAvKioKICAqIHBjaV9hcmlfZW5hYmxlZCAtIHF1ZXJ5IEFSSSBmb3J3YXJkaW5nIHN0YXR1cwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9wY2kvcHJvYmUuYyBiL2RyaXZlcnMvcGNpL3Byb2JlLmMKaW5kZXggMjMyMTJmOC4uOGQyZjQwMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9wY2kvcHJvYmUuYworKysgYi9kcml2ZXJzL3BjaS9wcm9iZS5jCkBAIC0xODk1LDcgKzE4OTUsNyBAQAogCWludCBlcnJvcjsKIAlzdHJ1Y3QgcGNpX2hvc3RfYnJpZGdlICpicmlkZ2U7CiAJc3RydWN0IHBjaV9idXMgKmIsICpiMjsKLQlzdHJ1Y3QgcGNpX2hvc3RfYnJpZGdlX3dpbmRvdyAqd2luZG93LCAqbjsKKwlzdHJ1Y3QgcmVzb3VyY2VfZW50cnkgKndpbmRvdywgKm47CiAJc3RydWN0IHJlc291cmNlICpyZXM7CiAJcmVzb3VyY2Vfc2l6ZV90IG9mZnNldDsKIAljaGFyIGJ1c19hZGRyWzY0XTsKQEAgLTE5NTksOCArMTk1OSw4IEBACiAJCXByaW50ayhLRVJOX0lORk8gIlBDSSBob3N0IGJyaWRnZSB0byBidXMgJXNcbiIsIGRldl9uYW1lKCZiLT5kZXYpKTsKIAogCS8qIEFkZCBpbml0aWFsIHJlc291cmNlcyB0byB0aGUgYnVzICovCi0JbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHdpbmRvdywgbiwgcmVzb3VyY2VzLCBsaXN0KSB7Ci0JCWxpc3RfbW92ZV90YWlsKCZ3aW5kb3ctPmxpc3QsICZicmlkZ2UtPndpbmRvd3MpOworCXJlc291cmNlX2xpc3RfZm9yX2VhY2hfZW50cnlfc2FmZSh3aW5kb3csIG4sIHJlc291cmNlcykgeworCQlsaXN0X21vdmVfdGFpbCgmd2luZG93LT5ub2RlLCAmYnJpZGdlLT53aW5kb3dzKTsKIAkJcmVzID0gd2luZG93LT5yZXM7CiAJCW9mZnNldCA9IHdpbmRvdy0+b2Zmc2V0OwogCQlpZiAocmVzLT5mbGFncyAmIElPUkVTT1VSQ0VfQlVTKQpAQCAtMjA2MCwxMiArMjA2MCwxMiBAQAogc3RydWN0IHBjaV9idXMgKnBjaV9zY2FuX3Jvb3RfYnVzKHN0cnVjdCBkZXZpY2UgKnBhcmVudCwgaW50IGJ1cywKIAkJc3RydWN0IHBjaV9vcHMgKm9wcywgdm9pZCAqc3lzZGF0YSwgc3RydWN0IGxpc3RfaGVhZCAqcmVzb3VyY2VzKQogewotCXN0cnVjdCBwY2lfaG9zdF9icmlkZ2Vfd2luZG93ICp3aW5kb3c7CisJc3RydWN0IHJlc291cmNlX2VudHJ5ICp3aW5kb3c7CiAJYm9vbCBmb3VuZCA9IGZhbHNlOwogCXN0cnVjdCBwY2lfYnVzICpiOwogCWludCBtYXg7CiAKLQlsaXN0X2Zvcl9lYWNoX2VudHJ5KHdpbmRvdywgcmVzb3VyY2VzLCBsaXN0KQorCXJlc291cmNlX2xpc3RfZm9yX2VhY2hfZW50cnkod2luZG93LCByZXNvdXJjZXMpCiAJCWlmICh3aW5kb3ctPnJlcy0+ZmxhZ3MgJiBJT1JFU09VUkNFX0JVUykgewogCQkJZm91bmQgPSB0cnVlOwogCQkJYnJlYWs7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9xdWlya3MuYyBiL2RyaXZlcnMvcGNpL3F1aXJrcy5jCmluZGV4IGVkNmY4OWIuLjkwM2Q1MDcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGNpL3F1aXJrcy5jCisrKyBiL2RyaXZlcnMvcGNpL3F1aXJrcy5jCkBAIC0zMjQsMTggKzMyNCw1MiBAQAogREVDTEFSRV9QQ0lfRklYVVBfSEVBREVSKFBDSV9WRU5ET1JfSURfUzMsCVBDSV9ERVZJQ0VfSURfUzNfODY4LAkJcXVpcmtfczNfNjRNKTsKIERFQ0xBUkVfUENJX0ZJWFVQX0hFQURFUihQQ0lfVkVORE9SX0lEX1MzLAlQQ0lfREVWSUNFX0lEX1MzXzk2OCwJCXF1aXJrX3MzXzY0TSk7CiAKK3N0YXRpYyB2b2lkIHF1aXJrX2lvKHN0cnVjdCBwY2lfZGV2ICpkZXYsIGludCBwb3MsIHVuc2lnbmVkIHNpemUsCisJCSAgICAgY29uc3QgY2hhciAqbmFtZSkKK3sKKwl1MzIgcmVnaW9uOworCXN0cnVjdCBwY2lfYnVzX3JlZ2lvbiBidXNfcmVnaW9uOworCXN0cnVjdCByZXNvdXJjZSAqcmVzID0gZGV2LT5yZXNvdXJjZSArIHBvczsKKworCXBjaV9yZWFkX2NvbmZpZ19kd29yZChkZXYsIFBDSV9CQVNFX0FERFJFU1NfMCArIChwb3MgPDwgMiksICZyZWdpb24pOworCisJaWYgKCFyZWdpb24pCisJCXJldHVybjsKKworCXJlcy0+bmFtZSA9IHBjaV9uYW1lKGRldik7CisJcmVzLT5mbGFncyA9IHJlZ2lvbiAmIH5QQ0lfQkFTRV9BRERSRVNTX0lPX01BU0s7CisJcmVzLT5mbGFncyB8PQorCQkoSU9SRVNPVVJDRV9JTyB8IElPUkVTT1VSQ0VfUENJX0ZJWEVEIHwgSU9SRVNPVVJDRV9TSVpFQUxJR04pOworCXJlZ2lvbiAmPSB+KHNpemUgLSAxKTsKKworCS8qIENvbnZlcnQgZnJvbSBQQ0kgYnVzIHRvIHJlc291cmNlIHNwYWNlICovCisJYnVzX3JlZ2lvbi5zdGFydCA9IHJlZ2lvbjsKKwlidXNfcmVnaW9uLmVuZCA9IHJlZ2lvbiArIHNpemUgLSAxOworCXBjaWJpb3NfYnVzX3RvX3Jlc291cmNlKGRldi0+YnVzLCByZXMsICZidXNfcmVnaW9uKTsKKworCWRldl9pbmZvKCZkZXYtPmRldiwgRldfQlVHICIlcyBxdWlyazogcmVnIDB4JXg6ICVwUlxuIiwKKwkJIG5hbWUsIFBDSV9CQVNFX0FERFJFU1NfMCArIChwb3MgPDwgMiksIHJlcyk7Cit9CisKIC8qCiAgKiBTb21lIENTNTUzNiBCSU9TZXMgKGZvciBleGFtcGxlLCB0aGUgU29la3JpcyBORVQ1NTAxIGJvYXJkIHcvIGNvbUJJT1MKICAqIHZlci4gMS4zMyAgMjAwNzAxMDMpIGRvbid0IHNldCB0aGUgY29ycmVjdCBJU0EgUENJIHJlZ2lvbiBoZWFkZXIgaW5mby4KICAqIEJBUjAgc2hvdWxkIGJlIDggYnl0ZXM7IGluc3RlYWQsIGl0IG1heSBiZSBzZXQgdG8gc29tZXRoaW5nIGxpa2UgOGsKICAqICh3aGljaCBjb25mbGljdHMgdy8gQkFSMSdzIG1lbW9yeSByYW5nZSkuCisgKgorICogQ1M1NTN4J3MgSVNBIFBDSSBCQVJzIG1heSBhbHNvIGJlIHJlYWQtb25seSAocmVmOgorICogaHR0cHM6Ly9idWd6aWxsYS5rZXJuZWwub3JnL3Nob3dfYnVnLmNnaT9pZD04NTk5MSAtIENvbW1lbnQgIzQgZm9yd2FyZCkuCiAgKi8KIHN0YXRpYyB2b2lkIHF1aXJrX2NzNTUzNl92c2Eoc3RydWN0IHBjaV9kZXYgKmRldikKIHsKKwlzdGF0aWMgY2hhciAqbmFtZSA9ICJDUzU1MzYgSVNBIGJyaWRnZSI7CisKIAlpZiAocGNpX3Jlc291cmNlX2xlbihkZXYsIDApICE9IDgpIHsKLQkJc3RydWN0IHJlc291cmNlICpyZXMgPSAmZGV2LT5yZXNvdXJjZVswXTsKLQkJcmVzLT5lbmQgPSByZXMtPnN0YXJ0ICsgOCAtIDE7Ci0JCWRldl9pbmZvKCZkZXYtPmRldiwgIkNTNTUzNiBJU0EgYnJpZGdlIGJ1ZyBkZXRlY3RlZCAoaW5jb3JyZWN0IGhlYWRlcik7IHdvcmthcm91bmQgYXBwbGllZFxuIik7CisJCXF1aXJrX2lvKGRldiwgMCwgICA4LCBuYW1lKTsJLyogU01CICovCisJCXF1aXJrX2lvKGRldiwgMSwgMjU2LCBuYW1lKTsJLyogR1BJTyAqLworCQlxdWlya19pbyhkZXYsIDIsICA2NCwgbmFtZSk7CS8qIE1GR1BUICovCisJCWRldl9pbmZvKCZkZXYtPmRldiwgIiVzIGJ1ZyBkZXRlY3RlZCAoaW5jb3JyZWN0IGhlYWRlcik7IHdvcmthcm91bmQgYXBwbGllZFxuIiwKKwkJCSBuYW1lKTsKIAl9CiB9CiBERUNMQVJFX1BDSV9GSVhVUF9IRUFERVIoUENJX1ZFTkRPUl9JRF9BTUQsIFBDSV9ERVZJQ0VfSURfQU1EX0NTNTUzNl9JU0EsIHF1aXJrX2NzNTUzNl92c2EpOwpAQCAtMzAyOCw2ICszMDYyLDIwIEBACiBERUNMQVJFX1BDSV9GSVhVUF9IRUFERVIoUENJX1ZFTkRPUl9JRF9NRUxMQU5PWCwgUENJX0FOWV9JRCwKIAkJCSBxdWlya19icm9rZW5faW50eF9tYXNraW5nKTsKIAorc3RhdGljIHZvaWQgcXVpcmtfbm9fYnVzX3Jlc2V0KHN0cnVjdCBwY2lfZGV2ICpkZXYpCit7CisJZGV2LT5kZXZfZmxhZ3MgfD0gUENJX0RFVl9GTEFHU19OT19CVVNfUkVTRVQ7Cit9CisKKy8qCisgKiBBdGhlcm9zIEFSOTN4eCBjaGlwcyBkbyBub3QgYmVoYXZlIGFmdGVyIGEgYnVzIHJlc2V0LiAgVGhlIGRldmljZSB3aWxsCisgKiB0aHJvdyBhIExpbmsgRG93biBlcnJvciBvbiBBRVItY2FwYWJsZSBzeXN0ZW1zIGFuZCByZWdhcmRsZXNzIG9mIEFFUiwKKyAqIGNvbmZpZyBzcGFjZSBvZiB0aGUgZGV2aWNlIGlzIG5ldmVyIGFjY2Vzc2libGUgYWdhaW4gYW5kIHR5cGljYWxseQorICogY2F1c2VzIHRoZSBzeXN0ZW0gdG8gaGFuZyBvciByZXNldCB3aGVuIGFjY2VzcyBpcyBhdHRlbXB0ZWQuCisgKiBodHRwOi8vd3d3LnNwaW5pY3MubmV0L2xpc3RzL2xpbnV4LXBjaS9tc2czNDc5Ny5odG1sCisgKi8KK0RFQ0xBUkVfUENJX0ZJWFVQX0hFQURFUihQQ0lfVkVORE9SX0lEX0FUSEVST1MsIDB4MDAzMCwgcXVpcmtfbm9fYnVzX3Jlc2V0KTsKKwogI2lmZGVmIENPTkZJR19BQ1BJCiAvKgogICogQXBwbGU6IFNodXRkb3duIENhY3R1cyBSaWRnZSBUaHVuZGVyYm9sdCBjb250cm9sbGVyLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9wY2kvc2V0dXAtYnVzLmMgYi9kcml2ZXJzL3BjaS9zZXR1cC1idXMuYwppbmRleCAwNDgyMjM1Li5lM2UxN2YzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BjaS9zZXR1cC1idXMuYworKysgYi9kcml2ZXJzL3BjaS9zZXR1cC1idXMuYwpAQCAtNTMwLDkgKzUzMCw4IEBACiAgICBjb25maWcgc3BhY2Ugd3JpdGVzLCBzbyBpdCdzIHF1aXRlIHBvc3NpYmxlIHRoYXQgYW4gSS9PIHdpbmRvdyBvZgogICAgdGhlIGJyaWRnZSB3aWxsIGhhdmUgc29tZSB1bmRlc2lyYWJsZSBhZGRyZXNzIChlLmcuIDApIGFmdGVyIHRoZQogICAgZmlyc3Qgd3JpdGUuIERpdHRvIDY0LWJpdCBwcmVmZXRjaGFibGUgTU1JTy4gICovCi1zdGF0aWMgdm9pZCBwY2lfc2V0dXBfYnJpZGdlX2lvKHN0cnVjdCBwY2lfYnVzICpidXMpCitzdGF0aWMgdm9pZCBwY2lfc2V0dXBfYnJpZGdlX2lvKHN0cnVjdCBwY2lfZGV2ICpicmlkZ2UpCiB7Ci0Jc3RydWN0IHBjaV9kZXYgKmJyaWRnZSA9IGJ1cy0+c2VsZjsKIAlzdHJ1Y3QgcmVzb3VyY2UgKnJlczsKIAlzdHJ1Y3QgcGNpX2J1c19yZWdpb24gcmVnaW9uOwogCXVuc2lnbmVkIGxvbmcgaW9fbWFzazsKQEAgLTU0NSw3ICs1NDQsNyBAQAogCQlpb19tYXNrID0gUENJX0lPXzFLX1JBTkdFX01BU0s7CiAKIAkvKiBTZXQgdXAgdGhlIHRvcCBhbmQgYm90dG9tIG9mIHRoZSBQQ0kgSS9PIHNlZ21lbnQgZm9yIHRoaXMgYnVzLiAqLwotCXJlcyA9IGJ1cy0+cmVzb3VyY2VbMF07CisJcmVzID0gJmJyaWRnZS0+cmVzb3VyY2VbUENJX0JSSURHRV9SRVNPVVJDRVMgKyAwXTsKIAlwY2liaW9zX3Jlc291cmNlX3RvX2J1cyhicmlkZ2UtPmJ1cywgJnJlZ2lvbiwgcmVzKTsKIAlpZiAocmVzLT5mbGFncyAmIElPUkVTT1VSQ0VfSU8pIHsKIAkJcGNpX3JlYWRfY29uZmlnX3dvcmQoYnJpZGdlLCBQQ0lfSU9fQkFTRSwgJmwpOwpAQCAtNTY4LDE1ICs1NjcsMTQgQEAKIAlwY2lfd3JpdGVfY29uZmlnX2R3b3JkKGJyaWRnZSwgUENJX0lPX0JBU0VfVVBQRVIxNiwgaW9fdXBwZXIxNik7CiB9CiAKLXN0YXRpYyB2b2lkIHBjaV9zZXR1cF9icmlkZ2VfbW1pbyhzdHJ1Y3QgcGNpX2J1cyAqYnVzKQorc3RhdGljIHZvaWQgcGNpX3NldHVwX2JyaWRnZV9tbWlvKHN0cnVjdCBwY2lfZGV2ICpicmlkZ2UpCiB7Ci0Jc3RydWN0IHBjaV9kZXYgKmJyaWRnZSA9IGJ1cy0+c2VsZjsKIAlzdHJ1Y3QgcmVzb3VyY2UgKnJlczsKIAlzdHJ1Y3QgcGNpX2J1c19yZWdpb24gcmVnaW9uOwogCXUzMiBsOwogCiAJLyogU2V0IHVwIHRoZSB0b3AgYW5kIGJvdHRvbSBvZiB0aGUgUENJIE1lbW9yeSBzZWdtZW50IGZvciB0aGlzIGJ1cy4gKi8KLQlyZXMgPSBidXMtPnJlc291cmNlWzFdOworCXJlcyA9ICZicmlkZ2UtPnJlc291cmNlW1BDSV9CUklER0VfUkVTT1VSQ0VTICsgMV07CiAJcGNpYmlvc19yZXNvdXJjZV90b19idXMoYnJpZGdlLT5idXMsICZyZWdpb24sIHJlcyk7CiAJaWYgKHJlcy0+ZmxhZ3MgJiBJT1JFU09VUkNFX01FTSkgewogCQlsID0gKHJlZ2lvbi5zdGFydCA+PiAxNikgJiAweGZmZjA7CkBAIC01ODgsOSArNTg2LDggQEAKIAlwY2lfd3JpdGVfY29uZmlnX2R3b3JkKGJyaWRnZSwgUENJX01FTU9SWV9CQVNFLCBsKTsKIH0KIAotc3RhdGljIHZvaWQgcGNpX3NldHVwX2JyaWRnZV9tbWlvX3ByZWYoc3RydWN0IHBjaV9idXMgKmJ1cykKK3N0YXRpYyB2b2lkIHBjaV9zZXR1cF9icmlkZ2VfbW1pb19wcmVmKHN0cnVjdCBwY2lfZGV2ICpicmlkZ2UpCiB7Ci0Jc3RydWN0IHBjaV9kZXYgKmJyaWRnZSA9IGJ1cy0+c2VsZjsKIAlzdHJ1Y3QgcmVzb3VyY2UgKnJlczsKIAlzdHJ1Y3QgcGNpX2J1c19yZWdpb24gcmVnaW9uOwogCXUzMiBsLCBidSwgbHU7CkBAIC02MDIsNyArNTk5LDcgQEAKIAogCS8qIFNldCB1cCBQUkVGIGJhc2UvbGltaXQuICovCiAJYnUgPSBsdSA9IDA7Ci0JcmVzID0gYnVzLT5yZXNvdXJjZVsyXTsKKwlyZXMgPSAmYnJpZGdlLT5yZXNvdXJjZVtQQ0lfQlJJREdFX1JFU09VUkNFUyArIDJdOwogCXBjaWJpb3NfcmVzb3VyY2VfdG9fYnVzKGJyaWRnZS0+YnVzLCAmcmVnaW9uLCByZXMpOwogCWlmIChyZXMtPmZsYWdzICYgSU9SRVNPVVJDRV9QUkVGRVRDSCkgewogCQlsID0gKHJlZ2lvbi5zdGFydCA+PiAxNikgJiAweGZmZjA7CkBAIC02MzAsMTMgKzYyNywxMyBAQAogCQkgJmJ1cy0+YnVzbl9yZXMpOwogCiAJaWYgKHR5cGUgJiBJT1JFU09VUkNFX0lPKQotCQlwY2lfc2V0dXBfYnJpZGdlX2lvKGJ1cyk7CisJCXBjaV9zZXR1cF9icmlkZ2VfaW8oYnJpZGdlKTsKIAogCWlmICh0eXBlICYgSU9SRVNPVVJDRV9NRU0pCi0JCXBjaV9zZXR1cF9icmlkZ2VfbW1pbyhidXMpOworCQlwY2lfc2V0dXBfYnJpZGdlX21taW8oYnJpZGdlKTsKIAogCWlmICh0eXBlICYgSU9SRVNPVVJDRV9QUkVGRVRDSCkKLQkJcGNpX3NldHVwX2JyaWRnZV9tbWlvX3ByZWYoYnVzKTsKKwkJcGNpX3NldHVwX2JyaWRnZV9tbWlvX3ByZWYoYnJpZGdlKTsKIAogCXBjaV93cml0ZV9jb25maWdfd29yZChicmlkZ2UsIFBDSV9CUklER0VfQ09OVFJPTCwgYnVzLT5icmlkZ2VfY3RsKTsKIH0KQEAgLTY0OSw2ICs2NDYsNDEgQEAKIAlfX3BjaV9zZXR1cF9icmlkZ2UoYnVzLCB0eXBlKTsKIH0KIAorCitpbnQgcGNpX2NsYWltX2JyaWRnZV9yZXNvdXJjZShzdHJ1Y3QgcGNpX2RldiAqYnJpZGdlLCBpbnQgaSkKK3sKKwlpZiAoaSA8IFBDSV9CUklER0VfUkVTT1VSQ0VTIHx8IGkgPiBQQ0lfQlJJREdFX1JFU09VUkNFX0VORCkKKwkJcmV0dXJuIDA7CisKKwlpZiAocGNpX2NsYWltX3Jlc291cmNlKGJyaWRnZSwgaSkgPT0gMCkKKwkJcmV0dXJuIDA7CS8qIGNsYWltZWQgdGhlIHdpbmRvdyAqLworCisJaWYgKChicmlkZ2UtPmNsYXNzID4+IDgpICE9IFBDSV9DTEFTU19CUklER0VfUENJKQorCQlyZXR1cm4gMDsKKworCWlmICghcGNpX2J1c19jbGlwX3Jlc291cmNlKGJyaWRnZSwgaSkpCisJCXJldHVybiAtRUlOVkFMOwkvKiBjbGlwcGluZyBkaWRuJ3QgY2hhbmdlIGFueXRoaW5nICovCisKKwlzd2l0Y2ggKGkgLSBQQ0lfQlJJREdFX1JFU09VUkNFUykgeworCWNhc2UgMDoKKwkJcGNpX3NldHVwX2JyaWRnZV9pbyhicmlkZ2UpOworCQlicmVhazsKKwljYXNlIDE6CisJCXBjaV9zZXR1cF9icmlkZ2VfbW1pbyhicmlkZ2UpOworCQlicmVhazsKKwljYXNlIDI6CisJCXBjaV9zZXR1cF9icmlkZ2VfbW1pb19wcmVmKGJyaWRnZSk7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCWlmIChwY2lfY2xhaW1fcmVzb3VyY2UoYnJpZGdlLCBpKSA9PSAwKQorCQlyZXR1cm4gMDsJLyogY2xhaW1lZCBhIHNtYWxsZXIgd2luZG93ICovCisKKwlyZXR1cm4gLUVJTlZBTDsKK30KKwogLyogQ2hlY2sgd2hldGhlciB0aGUgYnJpZGdlIHN1cHBvcnRzIG9wdGlvbmFsIEkvTyBhbmQKICAgIHByZWZldGNoYWJsZSBtZW1vcnkgcmFuZ2VzLiBJZiBub3QsIHRoZSByZXNwZWN0aXZlCiAgICBiYXNlL2xpbWl0IHJlZ2lzdGVycyBtdXN0IGJlIHJlYWQtb25seSBhbmQgcmVhZCBhcyAwLiAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9waW5jdHJsL2NvcmUuYyBiL2RyaXZlcnMvcGluY3RybC9jb3JlLmMKaW5kZXggZTRmNjU1MS4uODlkY2E3NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9waW5jdHJsL2NvcmUuYworKysgYi9kcml2ZXJzL3BpbmN0cmwvY29yZS5jCkBAIC0xODAxLDE0ICsxODAxLDE1IEBACiAJaWYgKHBjdGxkZXYgPT0gTlVMTCkKIAkJcmV0dXJuOwogCi0JbXV0ZXhfbG9jaygmcGluY3RybGRldl9saXN0X211dGV4KTsKIAltdXRleF9sb2NrKCZwY3RsZGV2LT5tdXRleCk7Ci0KIAlwaW5jdHJsX3JlbW92ZV9kZXZpY2VfZGVidWdmcyhwY3RsZGV2KTsKKwltdXRleF91bmxvY2soJnBjdGxkZXYtPm11dGV4KTsKIAogCWlmICghSVNfRVJSKHBjdGxkZXYtPnApKQogCQlwaW5jdHJsX3B1dChwY3RsZGV2LT5wKTsKIAorCW11dGV4X2xvY2soJnBpbmN0cmxkZXZfbGlzdF9tdXRleCk7CisJbXV0ZXhfbG9jaygmcGN0bGRldi0+bXV0ZXgpOwogCS8qIFRPRE86IGNoZWNrIHRoYXQgbm8gcGlubXV4ZXMgYXJlIHN0aWxsIGFjdGl2ZT8gKi8KIAlsaXN0X2RlbCgmcGN0bGRldi0+bm9kZSk7CiAJLyogRGVzdHJveSBkZXNjcmlwdG9yIHRyZWUgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGluY3RybC9waW5jdHJsLWF0OTEuYyBiL2RyaXZlcnMvcGluY3RybC9waW5jdHJsLWF0OTEuYwppbmRleCBkZmQwMjFlLi5mNGNkMGI5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3BpbmN0cmwvcGluY3RybC1hdDkxLmMKKysrIGIvZHJpdmVycy9waW5jdHJsL3BpbmN0cmwtYXQ5MS5jCkBAIC0xNzcsNyArMTc3LDcgQEAKIAlzdHJ1Y3QgZGV2aWNlCQkqZGV2OwogCXN0cnVjdCBwaW5jdHJsX2RldgkqcGN0bDsKIAotCWludAkJCW5iYW5rczsKKwlpbnQJCQluYWN0aXZlX2JhbmtzOwogCiAJdWludDMyX3QJCSptdXhfbWFzazsKIAlpbnQJCQlubXV4OwpAQCAtNjUzLDEyICs2NTMsMTggQEAKIAlpbnQgbXV4OwogCiAJLyogY2hlY2sgaWYgaXQncyBhIHZhbGlkIGNvbmZpZyAqLwotCWlmIChwaW4tPmJhbmsgPj0gaW5mby0+bmJhbmtzKSB7CisJaWYgKHBpbi0+YmFuayA+PSBncGlvX2JhbmtzKSB7CiAJCWRldl9lcnIoaW5mby0+ZGV2LCAiJXM6IHBpbiBjb25mICVkIGJhbmtfaWQgJWQgPj0gbmJhbmtzICVkXG4iLAotCQkJbmFtZSwgaW5kZXgsIHBpbi0+YmFuaywgaW5mby0+bmJhbmtzKTsKKwkJCW5hbWUsIGluZGV4LCBwaW4tPmJhbmssIGdwaW9fYmFua3MpOwogCQlyZXR1cm4gLUVJTlZBTDsKIAl9CiAKKwlpZiAoIWdwaW9fY2hpcHNbcGluLT5iYW5rXSkgeworCQlkZXZfZXJyKGluZm8tPmRldiwgIiVzOiBwaW4gY29uZiAlZCBiYW5rX2lkICVkIG5vdCBlbmFibGVkXG4iLAorCQkJbmFtZSwgaW5kZXgsIHBpbi0+YmFuayk7CisJCXJldHVybiAtRU5YSU87CisJfQorCiAJaWYgKHBpbi0+cGluID49IE1BWF9OQl9HUElPX1BFUl9CQU5LKSB7CiAJCWRldl9lcnIoaW5mby0+ZGV2LCAiJXM6IHBpbiBjb25mICVkIHBpbl9iYW5rX2lkICVkID49ICVkXG4iLAogCQkJbmFtZSwgaW5kZXgsIHBpbi0+cGluLCBNQVhfTkJfR1BJT19QRVJfQkFOSyk7CkBAIC05ODEsNyArOTg3LDggQEAKIAogCWZvcl9lYWNoX2NoaWxkX29mX25vZGUobnAsIGNoaWxkKSB7CiAJCWlmIChvZl9kZXZpY2VfaXNfY29tcGF0aWJsZShjaGlsZCwgZ3Bpb19jb21wYXQpKSB7Ci0JCQlpbmZvLT5uYmFua3MrKzsKKwkJCWlmIChvZl9kZXZpY2VfaXNfYXZhaWxhYmxlKGNoaWxkKSkKKwkJCQlpbmZvLT5uYWN0aXZlX2JhbmtzKys7CiAJCX0gZWxzZSB7CiAJCQlpbmZvLT5uZnVuY3Rpb25zKys7CiAJCQlpbmZvLT5uZ3JvdXBzICs9IG9mX2dldF9jaGlsZF9jb3VudChjaGlsZCk7CkBAIC0xMDAzLDExICsxMDEwLDExIEBACiAJfQogCiAJc2l6ZSAvPSBzaXplb2YoKmxpc3QpOwotCWlmICghc2l6ZSB8fCBzaXplICUgaW5mby0+bmJhbmtzKSB7Ci0JCWRldl9lcnIoaW5mby0+ZGV2LCAid3JvbmcgbXV4IG1hc2sgYXJyYXkgc2hvdWxkIGJlIGJ5ICVkXG4iLCBpbmZvLT5uYmFua3MpOworCWlmICghc2l6ZSB8fCBzaXplICUgZ3Bpb19iYW5rcykgeworCQlkZXZfZXJyKGluZm8tPmRldiwgIndyb25nIG11eCBtYXNrIGFycmF5IHNob3VsZCBiZSBieSAlZFxuIiwgZ3Bpb19iYW5rcyk7CiAJCXJldHVybiAtRUlOVkFMOwogCX0KLQlpbmZvLT5ubXV4ID0gc2l6ZSAvIGluZm8tPm5iYW5rczsKKwlpbmZvLT5ubXV4ID0gc2l6ZSAvIGdwaW9fYmFua3M7CiAKIAlpbmZvLT5tdXhfbWFzayA9IGRldm1fa3phbGxvYyhpbmZvLT5kZXYsIHNpemVvZih1MzIpICogc2l6ZSwgR0ZQX0tFUk5FTCk7CiAJaWYgKCFpbmZvLT5tdXhfbWFzaykgewpAQCAtMTEzMSw3ICsxMTM4LDcgQEAKIAkJb2ZfbWF0Y2hfZGV2aWNlKGF0OTFfcGluY3RybF9vZl9tYXRjaCwgJnBkZXYtPmRldiktPmRhdGE7CiAJYXQ5MV9waW5jdHJsX2NoaWxkX2NvdW50KGluZm8sIG5wKTsKIAotCWlmIChpbmZvLT5uYmFua3MgPCAxKSB7CisJaWYgKGdwaW9fYmFua3MgPCAxKSB7CiAJCWRldl9lcnIoJnBkZXYtPmRldiwgInlvdSBuZWVkIHRvIHNwZWNpZnkgYXQgbGVhc3Qgb25lIGdwaW8tY29udHJvbGxlclxuIik7CiAJCXJldHVybiAtRUlOVkFMOwogCX0KQEAgLTExNDQsNyArMTE1MSw3IEBACiAKIAlkZXZfZGJnKCZwZGV2LT5kZXYsICJtdXgtbWFza1xuIik7CiAJdG1wID0gaW5mby0+bXV4X21hc2s7Ci0JZm9yIChpID0gMDsgaSA8IGluZm8tPm5iYW5rczsgaSsrKSB7CisJZm9yIChpID0gMDsgaSA8IGdwaW9fYmFua3M7IGkrKykgewogCQlmb3IgKGogPSAwOyBqIDwgaW5mby0+bm11eDsgaisrLCB0bXArKykgewogCQkJZGV2X2RiZygmcGRldi0+ZGV2LCAiJWQ6JWRcdDB4JXhcbiIsIGksIGosIHRtcFswXSk7CiAJCX0KQEAgLTExNjIsNyArMTE2OSw3IEBACiAJaWYgKCFpbmZvLT5ncm91cHMpCiAJCXJldHVybiAtRU5PTUVNOwogCi0JZGV2X2RiZygmcGRldi0+ZGV2LCAibmJhbmtzID0gJWRcbiIsIGluZm8tPm5iYW5rcyk7CisJZGV2X2RiZygmcGRldi0+ZGV2LCAibmJhbmtzID0gJWRcbiIsIGdwaW9fYmFua3MpOwogCWRldl9kYmcoJnBkZXYtPmRldiwgIm5mdW5jdGlvbnMgPSAlZFxuIiwgaW5mby0+bmZ1bmN0aW9ucyk7CiAJZGV2X2RiZygmcGRldi0+ZGV2LCAibmdyb3VwcyA9ICVkXG4iLCBpbmZvLT5uZ3JvdXBzKTsKIApAQCAtMTE4NSw3ICsxMTkyLDcgQEAKIHsKIAlzdHJ1Y3QgYXQ5MV9waW5jdHJsICppbmZvOwogCXN0cnVjdCBwaW5jdHJsX3Bpbl9kZXNjICpwZGVzYzsKLQlpbnQgcmV0LCBpLCBqLCBrOworCWludCByZXQsIGksIGosIGssIG5ncGlvX2NoaXBzX2VuYWJsZWQgPSAwOwogCiAJaW5mbyA9IGRldm1fa3phbGxvYygmcGRldi0+ZGV2LCBzaXplb2YoKmluZm8pLCBHRlBfS0VSTkVMKTsKIAlpZiAoIWluZm8pCkBAIC0xMjAwLDIzICsxMjA3LDI3IEBACiAJICogdG8gb2J0YWluIHJlZmVyZW5jZXMgdG8gdGhlIHN0cnVjdCBncGlvX2NoaXAgKiBmb3IgdGhlbSwgYW5kIHdlCiAJICogbmVlZCB0aGlzIHRvIHByb2NlZWQuCiAJICovCi0JZm9yIChpID0gMDsgaSA8IGluZm8tPm5iYW5rczsgaSsrKSB7Ci0JCWlmICghZ3Bpb19jaGlwc1tpXSkgewotCQkJZGV2X3dhcm4oJnBkZXYtPmRldiwgIkdQSU8gY2hpcCAlZCBub3QgcmVnaXN0ZXJlZCB5ZXRcbiIsIGkpOwotCQkJZGV2bV9rZnJlZSgmcGRldi0+ZGV2LCBpbmZvKTsKLQkJCXJldHVybiAtRVBST0JFX0RFRkVSOwotCQl9CisJZm9yIChpID0gMDsgaSA8IGdwaW9fYmFua3M7IGkrKykKKwkJaWYgKGdwaW9fY2hpcHNbaV0pCisJCQluZ3Bpb19jaGlwc19lbmFibGVkKys7CisKKwlpZiAobmdwaW9fY2hpcHNfZW5hYmxlZCA8IGluZm8tPm5hY3RpdmVfYmFua3MpIHsKKwkJZGV2X3dhcm4oJnBkZXYtPmRldiwKKwkJCSAiQWxsIEdQSU8gY2hpcHMgYXJlIG5vdCByZWdpc3RlcmVkIHlldCAoJWQvJWQpXG4iLAorCQkJIG5ncGlvX2NoaXBzX2VuYWJsZWQsIGluZm8tPm5hY3RpdmVfYmFua3MpOworCQlkZXZtX2tmcmVlKCZwZGV2LT5kZXYsIGluZm8pOworCQlyZXR1cm4gLUVQUk9CRV9ERUZFUjsKIAl9CiAKIAlhdDkxX3BpbmN0cmxfZGVzYy5uYW1lID0gZGV2X25hbWUoJnBkZXYtPmRldik7Ci0JYXQ5MV9waW5jdHJsX2Rlc2MubnBpbnMgPSBpbmZvLT5uYmFua3MgKiBNQVhfTkJfR1BJT19QRVJfQkFOSzsKKwlhdDkxX3BpbmN0cmxfZGVzYy5ucGlucyA9IGdwaW9fYmFua3MgKiBNQVhfTkJfR1BJT19QRVJfQkFOSzsKIAlhdDkxX3BpbmN0cmxfZGVzYy5waW5zID0gcGRlc2MgPQogCQlkZXZtX2t6YWxsb2MoJnBkZXYtPmRldiwgc2l6ZW9mKCpwZGVzYykgKiBhdDkxX3BpbmN0cmxfZGVzYy5ucGlucywgR0ZQX0tFUk5FTCk7CiAKIAlpZiAoIWF0OTFfcGluY3RybF9kZXNjLnBpbnMpCiAJCXJldHVybiAtRU5PTUVNOwogCi0JZm9yIChpID0gMCAsIGsgPSAwOyBpIDwgaW5mby0+bmJhbmtzOyBpKyspIHsKKwlmb3IgKGkgPSAwLCBrID0gMDsgaSA8IGdwaW9fYmFua3M7IGkrKykgewogCQlmb3IgKGogPSAwOyBqIDwgTUFYX05CX0dQSU9fUEVSX0JBTks7IGorKywgaysrKSB7CiAJCQlwZGVzYy0+bnVtYmVyID0gazsKIAkJCXBkZXNjLT5uYW1lID0ga2FzcHJpbnRmKEdGUF9LRVJORUwsICJwaW8lYyVkIiwgaSArICdBJywgaik7CkBAIC0xMjM0LDggKzEyNDUsOSBAQAogCX0KIAogCS8qIFdlIHdpbGwgaGFuZGxlIGEgcmFuZ2Ugb2YgR1BJTyBwaW5zICovCi0JZm9yIChpID0gMDsgaSA8IGluZm8tPm5iYW5rczsgaSsrKQotCQlwaW5jdHJsX2FkZF9ncGlvX3JhbmdlKGluZm8tPnBjdGwsICZncGlvX2NoaXBzW2ldLT5yYW5nZSk7CisJZm9yIChpID0gMDsgaSA8IGdwaW9fYmFua3M7IGkrKykKKwkJaWYgKGdwaW9fY2hpcHNbaV0pCisJCQlwaW5jdHJsX2FkZF9ncGlvX3JhbmdlKGluZm8tPnBjdGwsICZncGlvX2NoaXBzW2ldLT5yYW5nZSk7CiAKIAlkZXZfaW5mbygmcGRldi0+ZGV2LCAiaW5pdGlhbGl6ZWQgQVQ5MSBwaW5jdHJsIGRyaXZlclxuIik7CiAKQEAgLTE2MTMsOSArMTYyNSwxMCBAQAogc3RhdGljIGludCBhdDkxX2dwaW9fb2ZfaXJxX3NldHVwKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYsCiAJCQkJICBzdHJ1Y3QgYXQ5MV9ncGlvX2NoaXAgKmF0OTFfZ3BpbykKIHsKKwlzdHJ1Y3QgZ3Bpb19jaGlwCSpncGlvY2hpcF9wcmV2ID0gTlVMTDsKIAlzdHJ1Y3QgYXQ5MV9ncGlvX2NoaXAgICAqcHJldiA9IE5VTEw7CiAJc3RydWN0IGlycV9kYXRhCQkqZCA9IGlycV9nZXRfaXJxX2RhdGEoYXQ5MV9ncGlvLT5waW9jX3ZpcnEpOwotCWludCByZXQ7CisJaW50IHJldCwgaTsKIAogCWF0OTFfZ3Bpby0+cGlvY19od2lycSA9IGlycWRfdG9faHdpcnEoZCk7CiAKQEAgLTE2NDEsMjQgKzE2NTQsMzMgQEAKIAkJcmV0dXJuIHJldDsKIAl9CiAKLQkvKiBTZXR1cCBjaGFpbmVkIGhhbmRsZXIgKi8KLQlpZiAoYXQ5MV9ncGlvLT5waW9jX2lkeCkKLQkJcHJldiA9IGdwaW9fY2hpcHNbYXQ5MV9ncGlvLT5waW9jX2lkeCAtIDFdOwotCiAJLyogVGhlIHRvcCBsZXZlbCBoYW5kbGVyIGhhbmRsZXMgb25lIGJhbmsgb2YgR1BJT3MsIGV4Y2VwdAogCSAqIG9uIHNvbWUgU29DIGl0IGNhbiBoYW5kbGUgdXAgdG8gdGhyZWUuLi4KIAkgKiBXZSBvbmx5IHNldCB1cCB0aGUgaGFuZGxlciBmb3IgdGhlIGZpcnN0IG9mIHRoZSBsaXN0LgogCSAqLwotCWlmIChwcmV2ICYmIHByZXYtPm5leHQgPT0gYXQ5MV9ncGlvKQorCWdwaW9jaGlwX3ByZXYgPSBpcnFfZ2V0X2hhbmRsZXJfZGF0YShhdDkxX2dwaW8tPnBpb2NfdmlycSk7CisJaWYgKCFncGlvY2hpcF9wcmV2KSB7CisJCS8qIFRoZW4gcmVnaXN0ZXIgdGhlIGNoYWluIG9uIHRoZSBwYXJlbnQgSVJRICovCisJCWdwaW9jaGlwX3NldF9jaGFpbmVkX2lycWNoaXAoJmF0OTFfZ3Bpby0+Y2hpcCwKKwkJCQkJICAgICAmZ3Bpb19pcnFjaGlwLAorCQkJCQkgICAgIGF0OTFfZ3Bpby0+cGlvY192aXJxLAorCQkJCQkgICAgIGdwaW9faXJxX2hhbmRsZXIpOwogCQlyZXR1cm4gMDsKKwl9CiAKLQkvKiBUaGVuIHJlZ2lzdGVyIHRoZSBjaGFpbiBvbiB0aGUgcGFyZW50IElSUSAqLwotCWdwaW9jaGlwX3NldF9jaGFpbmVkX2lycWNoaXAoJmF0OTFfZ3Bpby0+Y2hpcCwKLQkJCQkgICAgICZncGlvX2lycWNoaXAsCi0JCQkJICAgICBhdDkxX2dwaW8tPnBpb2NfdmlycSwKLQkJCQkgICAgIGdwaW9faXJxX2hhbmRsZXIpOworCXByZXYgPSBjb250YWluZXJfb2YoZ3Bpb2NoaXBfcHJldiwgc3RydWN0IGF0OTFfZ3Bpb19jaGlwLCBjaGlwKTsKIAotCXJldHVybiAwOworCS8qIHdlIGNhbiBvbmx5IGhhdmUgMiBiYW5rcyBiZWZvcmUgKi8KKwlmb3IgKGkgPSAwOyBpIDwgMjsgaSsrKSB7CisJCWlmIChwcmV2LT5uZXh0KSB7CisJCQlwcmV2ID0gcHJldi0+bmV4dDsKKwkJfSBlbHNlIHsKKwkJCXByZXYtPm5leHQgPSBhdDkxX2dwaW87CisJCQlyZXR1cm4gMDsKKwkJfQorCX0KKworCXJldHVybiAtRUlOVkFMOwogfQogCiAvKiBUaGlzIHN0cnVjdHVyZSBpcyByZXBsaWNhdGVkIGZvciBlYWNoIEdQSU8gYmxvY2sgYWxsb2NhdGVkIGF0IHByb2JlIHRpbWUgKi8KQEAgLTE2NzUsMjQgKzE2OTcsNiBAQAogCS5uZ3BpbwkJCT0gTUFYX05CX0dQSU9fUEVSX0JBTkssCiB9OwogCi1zdGF0aWMgdm9pZCBhdDkxX2dwaW9fcHJvYmVfZml4dXAodm9pZCkKLXsKLQl1bnNpZ25lZCBpOwotCXN0cnVjdCBhdDkxX2dwaW9fY2hpcCAqYXQ5MV9ncGlvLCAqbGFzdCA9IE5VTEw7Ci0KLQlmb3IgKGkgPSAwOyBpIDwgZ3Bpb19iYW5rczsgaSsrKSB7Ci0JCWF0OTFfZ3BpbyA9IGdwaW9fY2hpcHNbaV07Ci0KLQkJLyoKLQkJICogR1BJTyBjb250cm9sbGVyIGFyZSBncm91cGVkIG9uIHNvbWUgU29DOgotCQkgKiBQSU9DLCBQSU9EIGFuZCBQSU9FIGNhbiBzaGFyZSB0aGUgc2FtZSBJUlEgbGluZQotCQkgKi8KLQkJaWYgKGxhc3QgJiYgbGFzdC0+cGlvY192aXJxID09IGF0OTFfZ3Bpby0+cGlvY192aXJxKQotCQkJbGFzdC0+bmV4dCA9IGF0OTFfZ3BpbzsKLQkJbGFzdCA9IGF0OTFfZ3BpbzsKLQl9Ci19Ci0KIHN0YXRpYyBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkIGF0OTFfZ3Bpb19vZl9tYXRjaFtdID0gewogCXsgLmNvbXBhdGlibGUgPSAiYXRtZWwsYXQ5MXNhbTl4NS1ncGlvIiwgLmRhdGEgPSAmYXQ5MXNhbTl4NV9vcHMsIH0sCiAJeyAuY29tcGF0aWJsZSA9ICJhdG1lbCxhdDkxcm05MjAwLWdwaW8iLCAuZGF0YSA9ICZhdDkxcm05MjAwX29wcyB9LApAQCAtMTgwNSw4ICsxODA5LDYgQEAKIAlncGlvX2NoaXBzW2FsaWFzX2lkeF0gPSBhdDkxX2NoaXA7CiAJZ3Bpb19iYW5rcyA9IG1heChncGlvX2JhbmtzLCBhbGlhc19pZHggKyAxKTsKIAotCWF0OTFfZ3Bpb19wcm9iZV9maXh1cCgpOwotCiAJcmV0ID0gYXQ5MV9ncGlvX29mX2lycV9zZXR1cChwZGV2LCBhdDkxX2NoaXApOwogCWlmIChyZXQpCiAJCWdvdG8gaXJxX3NldHVwX2VycjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGluY3RybC9waW5jdHJsLXJvY2tjaGlwLmMgYi9kcml2ZXJzL3BpbmN0cmwvcGluY3RybC1yb2NrY2hpcC5jCmluZGV4IDNjMjJkYmUuLjQzZWFjYzkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGluY3RybC9waW5jdHJsLXJvY2tjaGlwLmMKKysrIGIvZHJpdmVycy9waW5jdHJsL3BpbmN0cmwtcm9ja2NoaXAuYwpAQCAtMTM5OCwxMCArMTM5OCw3IEBACiB7CiAJc3RydWN0IGlycV9jaGlwICpjaGlwID0gaXJxX2dldF9jaGlwKGlycSk7CiAJc3RydWN0IHJvY2tjaGlwX3Bpbl9iYW5rICpiYW5rID0gaXJxX2dldF9oYW5kbGVyX2RhdGEoaXJxKTsKLQl1MzIgcG9sYXJpdHkgPSAwLCBkYXRhID0gMDsKIAl1MzIgcGVuZDsKLQlib29sIGVkZ2VfY2hhbmdlZCA9IGZhbHNlOwotCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKIAlkZXZfZGJnKGJhbmstPmRydmRhdGEtPmRldiwgImdvdCBpcnEgZm9yIGJhbmsgJXNcbiIsIGJhbmstPm5hbWUpOwogCkBAIC0xNDA5LDEyICsxNDA2LDYgQEAKIAogCXBlbmQgPSByZWFkbF9yZWxheGVkKGJhbmstPnJlZ19iYXNlICsgR1BJT19JTlRfU1RBVFVTKTsKIAotCWlmIChiYW5rLT50b2dnbGVfZWRnZV9tb2RlKSB7Ci0JCXBvbGFyaXR5ID0gcmVhZGxfcmVsYXhlZChiYW5rLT5yZWdfYmFzZSArCi0JCQkJCSBHUElPX0lOVF9QT0xBUklUWSk7Ci0JCWRhdGEgPSByZWFkbF9yZWxheGVkKGJhbmstPnJlZ19iYXNlICsgR1BJT19FWFRfUE9SVCk7Ci0JfQotCiAJd2hpbGUgKHBlbmQpIHsKIAkJdW5zaWduZWQgaW50IHZpcnE7CiAKQEAgLTE0MzQsMjkgKzE0MjUsMzMgQEAKIAkJICogbmVlZHMgbWFudWFsIGludGVydmVudGlvbi4KIAkJICovCiAJCWlmIChiYW5rLT50b2dnbGVfZWRnZV9tb2RlICYgQklUKGlycSkpIHsKLQkJCWlmIChkYXRhICYgQklUKGlycSkpCi0JCQkJcG9sYXJpdHkgJj0gfkJJVChpcnEpOwotCQkJZWxzZQotCQkJCXBvbGFyaXR5IHw9IEJJVChpcnEpOworCQkJdTMyIGRhdGEsIGRhdGFfb2xkLCBwb2xhcml0eTsKKwkJCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKLQkJCWVkZ2VfY2hhbmdlZCA9IHRydWU7CisJCQlkYXRhID0gcmVhZGxfcmVsYXhlZChiYW5rLT5yZWdfYmFzZSArIEdQSU9fRVhUX1BPUlQpOworCQkJZG8geworCQkJCXNwaW5fbG9ja19pcnFzYXZlKCZiYW5rLT5zbG9jaywgZmxhZ3MpOworCisJCQkJcG9sYXJpdHkgPSByZWFkbF9yZWxheGVkKGJhbmstPnJlZ19iYXNlICsKKwkJCQkJCQkgR1BJT19JTlRfUE9MQVJJVFkpOworCQkJCWlmIChkYXRhICYgQklUKGlycSkpCisJCQkJCXBvbGFyaXR5ICY9IH5CSVQoaXJxKTsKKwkJCQllbHNlCisJCQkJCXBvbGFyaXR5IHw9IEJJVChpcnEpOworCQkJCXdyaXRlbChwb2xhcml0eSwKKwkJCQkgICAgICAgYmFuay0+cmVnX2Jhc2UgKyBHUElPX0lOVF9QT0xBUklUWSk7CisKKwkJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZiYW5rLT5zbG9jaywgZmxhZ3MpOworCisJCQkJZGF0YV9vbGQgPSBkYXRhOworCQkJCWRhdGEgPSByZWFkbF9yZWxheGVkKGJhbmstPnJlZ19iYXNlICsKKwkJCQkJCSAgICAgR1BJT19FWFRfUE9SVCk7CisJCQl9IHdoaWxlICgoZGF0YSAmIEJJVChpcnEpKSAhPSAoZGF0YV9vbGQgJiBCSVQoaXJxKSkpOwogCQl9CiAKIAkJZ2VuZXJpY19oYW5kbGVfaXJxKHZpcnEpOwogCX0KIAotCWlmIChiYW5rLT50b2dnbGVfZWRnZV9tb2RlICYmIGVkZ2VfY2hhbmdlZCkgewotCQkvKiBJbnRlcnJ1cHQgcGFyYW1zIHNob3VsZCBvbmx5IGJlIHNldCB3aXRoIGludHMgZGlzYWJsZWQgKi8KLQkJc3Bpbl9sb2NrX2lycXNhdmUoJmJhbmstPnNsb2NrLCBmbGFncyk7Ci0KLQkJZGF0YSA9IHJlYWRsX3JlbGF4ZWQoYmFuay0+cmVnX2Jhc2UgKyBHUElPX0lOVEVOKTsKLQkJd3JpdGVsX3JlbGF4ZWQoMCwgYmFuay0+cmVnX2Jhc2UgKyBHUElPX0lOVEVOKTsKLQkJd3JpdGVsKHBvbGFyaXR5LCBiYW5rLT5yZWdfYmFzZSArIEdQSU9fSU5UX1BPTEFSSVRZKTsKLQkJd3JpdGVsKGRhdGEsIGJhbmstPnJlZ19iYXNlICsgR1BJT19JTlRFTik7Ci0KLQkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYmFuay0+c2xvY2ssIGZsYWdzKTsKLQl9Ci0KIAljaGFpbmVkX2lycV9leGl0KGNoaXAsIGRlc2MpOwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BpbmN0cmwvcGluY3RybC14d2F5LmMgYi9kcml2ZXJzL3BpbmN0cmwvcGluY3RybC14d2F5LmMKaW5kZXggYzVjZWY1OS4uNzc5OTUwYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9waW5jdHJsL3BpbmN0cmwteHdheS5jCisrKyBiL2RyaXZlcnMvcGluY3RybC9waW5jdHJsLXh3YXkuYwpAQCAtNzk4LDEwICs3OTgsOCBAQAogCiAJLyogbG9hZCB0aGUgZ3BpbyBjaGlwICovCiAJeHdheV9jaGlwLmRldiA9ICZwZGV2LT5kZXY7Ci0Jb2ZfZ3Bpb2NoaXBfYWRkKCZ4d2F5X2NoaXApOwogCXJldCA9IGdwaW9jaGlwX2FkZCgmeHdheV9jaGlwKTsKIAlpZiAocmV0KSB7Ci0JCW9mX2dwaW9jaGlwX3JlbW92ZSgmeHdheV9jaGlwKTsKIAkJZGV2X2VycigmcGRldi0+ZGV2LCAiRmFpbGVkIHRvIHJlZ2lzdGVyIGdwaW8gY2hpcFxuIik7CiAJCXJldHVybiByZXQ7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9waW5jdHJsL3Fjb20vcGluY3RybC1tc20uYyBiL2RyaXZlcnMvcGluY3RybC9xY29tL3BpbmN0cmwtbXNtLmMKaW5kZXggZTczMDkzNS4uZWQ3MDE3ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9waW5jdHJsL3Fjb20vcGluY3RybC1tc20uYworKysgYi9kcml2ZXJzL3BpbmN0cmwvcWNvbS9waW5jdHJsLW1zbS5jCkBAIC04NjUsMTAgKzg2NSwxMCBAQAogCiBzdGF0aWMgdm9pZCBtc21fcGluY3RybF9zZXR1cF9wbV9yZXNldChzdHJ1Y3QgbXNtX3BpbmN0cmwgKnBjdHJsKQogewotCWludCBpID0gMDsKKwlpbnQgaTsKIAljb25zdCBzdHJ1Y3QgbXNtX2Z1bmN0aW9uICpmdW5jID0gcGN0cmwtPnNvYy0+ZnVuY3Rpb25zOwogCi0JZm9yICg7IGkgPD0gcGN0cmwtPnNvYy0+bmZ1bmN0aW9uczsgaSsrKQorCWZvciAoaSA9IDA7IGkgPCBwY3RybC0+c29jLT5uZnVuY3Rpb25zOyBpKyspCiAJCWlmICghc3RyY21wKGZ1bmNbaV0ubmFtZSwgInBzX2hvbGQiKSkgewogCQkJcGN0cmwtPnJlc3RhcnRfbmIubm90aWZpZXJfY2FsbCA9IG1zbV9wc19ob2xkX3Jlc3RhcnQ7CiAJCQlwY3RybC0+cmVzdGFydF9uYi5wcmlvcml0eSA9IDEyODsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGxhdGZvcm0veDg2L2RlbGwtbGFwdG9wLmMgYi9kcml2ZXJzL3BsYXRmb3JtL3g4Ni9kZWxsLWxhcHRvcC5jCmluZGV4IDk0MTFlYWUuLjNkMjFlZmUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGxhdGZvcm0veDg2L2RlbGwtbGFwdG9wLmMKKysrIGIvZHJpdmVycy9wbGF0Zm9ybS94ODYvZGVsbC1sYXB0b3AuYwpAQCAtMiwxMSArMiw5IEBACiAgKiAgRHJpdmVyIGZvciBEZWxsIGxhcHRvcCBleHRyYXMKICAqCiAgKiAgQ29weXJpZ2h0IChjKSBSZWQgSGF0IDxtamdAcmVkaGF0LmNvbT4KLSAqICBDb3B5cmlnaHQgKGMpIDIwMTQgR2FicmllbGUgTWF6em90dGEgPGdhYnJpZWxlLm16dEBnbWFpbC5jb20+Ci0gKiAgQ29weXJpZ2h0IChjKSAyMDE0IFBhbGkgUm9ow6FyIDxwYWxpLnJvaGFyQGdtYWlsLmNvbT4KICAqCi0gKiAgQmFzZWQgb24gZG9jdW1lbnRhdGlvbiBpbiB0aGUgbGlic21iaW9zIHBhY2thZ2U6Ci0gKiAgQ29weXJpZ2h0IChDKSAyMDA1LTIwMTQgRGVsbCBJbmMuCisgKiAgQmFzZWQgb24gZG9jdW1lbnRhdGlvbiBpbiB0aGUgbGlic21iaW9zIHBhY2thZ2UsIENvcHlyaWdodCAoQykgMjAwNSBEZWxsCisgKiAgSW5jLgogICoKICAqICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQogICogIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCkBAIC0zNCwxMyArMzIsNiBAQAogI2luY2x1ZGUgIi4uLy4uL2Zpcm13YXJlL2RjZGJhcy5oIgogCiAjZGVmaW5lIEJSSUdIVE5FU1NfVE9LRU4gMHg3ZAotI2RlZmluZSBLQkRfTEVEX09GRl9UT0tFTiAweDAxRTEKLSNkZWZpbmUgS0JEX0xFRF9PTl9UT0tFTiAweDAxRTIKLSNkZWZpbmUgS0JEX0xFRF9BVVRPX1RPS0VOIDB4MDFFMwotI2RlZmluZSBLQkRfTEVEX0FVVE9fMjVfVE9LRU4gMHgwMkVBCi0jZGVmaW5lIEtCRF9MRURfQVVUT181MF9UT0tFTiAweDAyRUIKLSNkZWZpbmUgS0JEX0xFRF9BVVRPXzc1X1RPS0VOIDB4MDJFQwotI2RlZmluZSBLQkRfTEVEX0FVVE9fMTAwX1RPS0VOIDB4MDJGNgogCiAvKiBUaGlzIHN0cnVjdHVyZSB3aWxsIGJlIG1vZGlmaWVkIGJ5IHRoZSBmaXJtd2FyZSB3aGVuIHdlIGVudGVyCiAgKiBzeXN0ZW0gbWFuYWdlbWVudCBtb2RlLCBoZW5jZSB0aGUgdm9sYXRpbGVzICovCkBAIC03MSwxMyArNjIsNiBAQAogCiBzdHJ1Y3QgcXVpcmtfZW50cnkgewogCXU4IHRvdWNocGFkX2xlZDsKLQotCWludCBuZWVkc19rYmRfdGltZW91dHM7Ci0JLyoKLQkgKiBPcmRlcmVkIGxpc3Qgb2YgdGltZW91dHMgZXhwcmVzc2VkIGluIHNlY29uZHMuCi0JICogVGhlIGxpc3QgbXVzdCBlbmQgd2l0aCAtMQotCSAqLwotCWludCBrYmRfdGltZW91dHNbXTsKIH07CiAKIHN0YXRpYyBzdHJ1Y3QgcXVpcmtfZW50cnkgKnF1aXJrczsKQEAgLTkyLDE1ICs3Niw2IEBACiAJcmV0dXJuIDE7CiB9CiAKLS8qCi0gKiBUaGVzZSB2YWx1ZXMgY29tZSBmcm9tIFdpbmRvd3MgdXRpbGl0eSBwcm92aWRlZCBieSBEZWxsLiBJZiBhbnkgb3RoZXIgdmFsdWUKLSAqIGlzIHVzZWQgdGhlbiBCSU9TIHNpbGVudGx5IHNldCB0aW1lb3V0IHRvIDAgd2l0aG91dCBhbnkgZXJyb3IgbWVzc2FnZS4KLSAqLwotc3RhdGljIHN0cnVjdCBxdWlya19lbnRyeSBxdWlya19kZWxsX3hwczEzXzkzMzMgPSB7Ci0JLm5lZWRzX2tiZF90aW1lb3V0cyA9IDEsCi0JLmtiZF90aW1lb3V0cyA9IHsgMCwgNSwgMTUsIDYwLCA1ICogNjAsIDE1ICogNjAsIC0xIH0sCi19OwotCiBzdGF0aWMgaW50IGRhX2NvbW1hbmRfYWRkcmVzczsKIHN0YXRpYyBpbnQgZGFfY29tbWFuZF9jb2RlOwogc3RhdGljIGludCBkYV9udW1fdG9rZW5zOwpAQCAtMjkyLDE1ICsyNjcsNiBAQAogCQl9LAogCQkuZHJpdmVyX2RhdGEgPSAmcXVpcmtfZGVsbF92b3N0cm9fdjEzMCwKIAl9LAotCXsKLQkJLmNhbGxiYWNrID0gZG1pX21hdGNoZWQsCi0JCS5pZGVudCA9ICJEZWxsIFhQUzEzIDkzMzMiLAotCQkubWF0Y2hlcyA9IHsKLQkJCURNSV9NQVRDSChETUlfU1lTX1ZFTkRPUiwgIkRlbGwgSW5jLiIpLAotCQkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJYUFMxMyA5MzMzIiksCi0JCX0sCi0JCS5kcml2ZXJfZGF0YSA9ICZxdWlya19kZWxsX3hwczEzXzkzMzMsCi0JfSwKIAl7IH0KIH07CiAKQEAgLTM2NSwyOSArMzMxLDE3IEBACiAJfQogfQogCi1zdGF0aWMgaW50IGZpbmRfdG9rZW5faWQoaW50IHRva2VuaWQpCitzdGF0aWMgaW50IGZpbmRfdG9rZW5fbG9jYXRpb24oaW50IHRva2VuaWQpCiB7CiAJaW50IGk7Ci0KIAlmb3IgKGkgPSAwOyBpIDwgZGFfbnVtX3Rva2VuczsgaSsrKSB7CiAJCWlmIChkYV90b2tlbnNbaV0udG9rZW5JRCA9PSB0b2tlbmlkKQotCQkJcmV0dXJuIGk7CisJCQlyZXR1cm4gZGFfdG9rZW5zW2ldLmxvY2F0aW9uOwogCX0KIAogCXJldHVybiAtMTsKIH0KIAotc3RhdGljIGludCBmaW5kX3Rva2VuX2xvY2F0aW9uKGludCB0b2tlbmlkKQotewotCWludCBpZDsKLQotCWlkID0gZmluZF90b2tlbl9pZCh0b2tlbmlkKTsKLQlpZiAoaWQgPT0gLTEpCi0JCXJldHVybiAtMTsKLQotCXJldHVybiBkYV90b2tlbnNbaWRdLmxvY2F0aW9uOwotfQotCiBzdGF0aWMgc3RydWN0IGNhbGxpbmdfaW50ZXJmYWNlX2J1ZmZlciAqCiBkZWxsX3NlbmRfcmVxdWVzdChzdHJ1Y3QgY2FsbGluZ19pbnRlcmZhY2VfYnVmZmVyICpidWZmZXIsIGludCBjbGFzcywKIAkJICBpbnQgc2VsZWN0KQpAQCAtNDA4LDIwICszNjIsNiBAQAogCXJldHVybiBidWZmZXI7CiB9CiAKLXN0YXRpYyBpbmxpbmUgaW50IGRlbGxfc21pX2Vycm9yKGludCB2YWx1ZSkKLXsKLQlzd2l0Y2ggKHZhbHVlKSB7Ci0JY2FzZSAwOiAvKiBDb21wbGV0ZWQgc3VjY2Vzc2Z1bGx5ICovCi0JCXJldHVybiAwOwotCWNhc2UgLTE6IC8qIENvbXBsZXRlZCB3aXRoIGVycm9yICovCi0JCXJldHVybiAtRUlPOwotCWNhc2UgLTI6IC8qIEZ1bmN0aW9uIG5vdCBzdXBwb3J0ZWQgKi8KLQkJcmV0dXJuIC1FTlhJTzsKLQlkZWZhdWx0OiAvKiBVbmtub3duIGVycm9yICovCi0JCXJldHVybiAtRUlOVkFMOwotCX0KLX0KLQogLyogRGVyaXZlZCBmcm9tIGluZm9ybWF0aW9uIGluIERlbGxXaXJlbGVzc0N0bC5jcHA6CiAgICBDbGFzcyAxNywgc2VsZWN0IDExIGlzIHJhZGlvIGNvbnRyb2wuIEl0IHJldHVybnMgYW4gYXJyYXkgb2YgMzItYml0IHZhbHVlcy4KIApAQCAtNzc2LDcgKzcxNiw3IEBACiAJZWxzZQogCQlkZWxsX3NlbmRfcmVxdWVzdChidWZmZXIsIDEsIDEpOwogCi0gb3V0Ogorb3V0OgogCXJlbGVhc2VfYnVmZmVyKCk7CiAJcmV0dXJuIHJldDsKIH0KQEAgLTgwMCw3ICs3NDAsNyBAQAogCiAJcmV0ID0gYnVmZmVyLT5vdXRwdXRbMV07CiAKLSBvdXQ6CitvdXQ6CiAJcmVsZWFzZV9idWZmZXIoKTsKIAlyZXR1cm4gcmV0OwogfQpAQCAtODQ5LDk4NCArNzg5LDYgQEAKIAlsZWRfY2xhc3NkZXZfdW5yZWdpc3RlcigmdG91Y2hwYWRfbGVkKTsKIH0KIAotLyoKLSAqIERlcml2ZWQgZnJvbSBpbmZvcm1hdGlvbiBpbiBzbWJpb3Mta2V5Ym9hcmQtY3RsOgotICoKLSAqIGNiQ2xhc3MgNAotICogY2JTZWxlY3QgMTEKLSAqIEtleWJvYXJkIGlsbHVtaW5hdGlvbgotICogY2JBcmcxIGRldGVybWluZXMgdGhlIGZ1bmN0aW9uIHRvIGJlIHBlcmZvcm1lZAotICoKLSAqIGNiQXJnMSAweDAgPSBHZXQgRmVhdHVyZSBJbmZvcm1hdGlvbgotICogIGNiUkVTMSAgICAgICAgIFN0YW5kYXJkIHJldHVybiBjb2RlcyAoMCwgLTEsIC0yKQotICogIGNiUkVTMiwgd29yZDAgIEJpdG1hcCBvZiB1c2VyLXNlbGVjdGFibGUgbW9kZXMKLSAqICAgICBiaXQgMCAgICAgQWx3YXlzIG9mZiAoQWxsIHN5c3RlbXMpCi0gKiAgICAgYml0IDEgICAgIEFsd2F5cyBvbiAoVHJhdmlzIEFURywgU2liZXJpYSkKLSAqICAgICBiaXQgMiAgICAgQXV0bzogQUxTLWJhc2VkIE9uOyBBTFMtYmFzZWQgT2ZmIChUcmF2aXMgQVRHKQotICogICAgIGJpdCAzICAgICBBdXRvOiBBTFMtIGFuZCBpbnB1dC1hY3Rpdml0eS1iYXNlZCBPbjsgaW5wdXQtYWN0aXZpdHkgYmFzZWQgT2ZmCi0gKiAgICAgYml0IDQgICAgIEF1dG86IElucHV0LWFjdGl2aXR5LWJhc2VkIE9uOyBpbnB1dC1hY3Rpdml0eSBiYXNlZCBPZmYKLSAqICAgICBiaXQgNSAgICAgQXV0bzogSW5wdXQtYWN0aXZpdHktYmFzZWQgT24gKGlsbHVtaW5hdGlvbiBsZXZlbCAyNSUpOyBpbnB1dC1hY3Rpdml0eSBiYXNlZCBPZmYKLSAqICAgICBiaXQgNiAgICAgQXV0bzogSW5wdXQtYWN0aXZpdHktYmFzZWQgT24gKGlsbHVtaW5hdGlvbiBsZXZlbCA1MCUpOyBpbnB1dC1hY3Rpdml0eSBiYXNlZCBPZmYKLSAqICAgICBiaXQgNyAgICAgQXV0bzogSW5wdXQtYWN0aXZpdHktYmFzZWQgT24gKGlsbHVtaW5hdGlvbiBsZXZlbCA3NSUpOyBpbnB1dC1hY3Rpdml0eSBiYXNlZCBPZmYKLSAqICAgICBiaXQgOCAgICAgQXV0bzogSW5wdXQtYWN0aXZpdHktYmFzZWQgT24gKGlsbHVtaW5hdGlvbiBsZXZlbCAxMDAlKTsgaW5wdXQtYWN0aXZpdHkgYmFzZWQgT2ZmCi0gKiAgICAgYml0cyA5LTE1IFJlc2VydmVkIGZvciBmdXR1cmUgdXNlCi0gKiAgY2JSRVMyLCBieXRlMiAgUmVzZXJ2ZWQgZm9yIGZ1dHVyZSB1c2UKLSAqICBjYlJFUzIsIGJ5dGUzICBLZXlib2FyZCBpbGx1bWluYXRpb24gdHlwZQotICogICAgIDAgICAgICAgICBSZXNlcnZlZAotICogICAgIDEgICAgICAgICBUYXNrbGlnaHQKLSAqICAgICAyICAgICAgICAgQmFja2xpZ2h0Ci0gKiAgICAgMy0yNTUgICAgIFJlc2VydmVkIGZvciBmdXR1cmUgdXNlCi0gKiAgY2JSRVMzLCBieXRlMCAgU3VwcG9ydGVkIGF1dG8ga2V5Ym9hcmQgaWxsdW1pbmF0aW9uIHRyaWdnZXIgYml0bWFwLgotICogICAgIGJpdCAwICAgICBBbnkga2V5c3Ryb2tlCi0gKiAgICAgYml0IDEgICAgIFRvdWNocGFkIGFjdGl2aXR5Ci0gKiAgICAgYml0IDIgICAgIFBvaW50aW5nIHN0aWNrCi0gKiAgICAgYml0IDMgICAgIEFueSBtb3VzZQotICogICAgIGJpdHMgNC03ICBSZXNlcnZlZCBmb3IgZnV0dXJlIHVzZQotICogIGNiUkVTMywgYnl0ZTEgIFN1cHBvcnRlZCB0aW1lb3V0IHVuaXQgYml0bWFwCi0gKiAgICAgYml0IDAgICAgIFNlY29uZHMKLSAqICAgICBiaXQgMSAgICAgTWludXRlcwotICogICAgIGJpdCAyICAgICBIb3VycwotICogICAgIGJpdCAzICAgICBEYXlzCi0gKiAgICAgYml0cyA0LTcgIFJlc2VydmVkIGZvciBmdXR1cmUgdXNlCi0gKiAgY2JSRVMzLCBieXRlMiAgTnVtYmVyIG9mIGtleWJvYXJkIGxpZ2h0IGJyaWdodG5lc3MgbGV2ZWxzCi0gKiAgY2JSRVM0LCBieXRlMCAgTWF4aW11bSBhY2NlcHRhYmxlIHNlY29uZHMgdmFsdWUgKDAgaWYgc2Vjb25kcyBub3Qgc3VwcG9ydGVkKS4KLSAqICBjYlJFUzQsIGJ5dGUxICBNYXhpbXVtIGFjY2VwdGFibGUgbWludXRlcyB2YWx1ZSAoMCBpZiBtaW51dGVzIG5vdCBzdXBwb3J0ZWQpLgotICogIGNiUkVTNCwgYnl0ZTIgIE1heGltdW0gYWNjZXB0YWJsZSBob3VycyB2YWx1ZSAoMCBpZiBob3VycyBub3Qgc3VwcG9ydGVkKS4KLSAqICBjYlJFUzQsIGJ5dGUzICBNYXhpbXVtIGFjY2VwdGFibGUgZGF5cyB2YWx1ZSAoMCBpZiBkYXlzIG5vdCBzdXBwb3J0ZWQpCi0gKgotICogY2JBcmcxIDB4MSA9IEdldCBDdXJyZW50IFN0YXRlCi0gKiAgY2JSRVMxICAgICAgICAgU3RhbmRhcmQgcmV0dXJuIGNvZGVzICgwLCAtMSwgLTIpCi0gKiAgY2JSRVMyLCB3b3JkMCAgQml0bWFwIG9mIGN1cnJlbnQgbW9kZSBzdGF0ZQotICogICAgIGJpdCAwICAgICBBbHdheXMgb2ZmIChBbGwgc3lzdGVtcykKLSAqICAgICBiaXQgMSAgICAgQWx3YXlzIG9uIChUcmF2aXMgQVRHLCBTaWJlcmlhKQotICogICAgIGJpdCAyICAgICBBdXRvOiBBTFMtYmFzZWQgT247IEFMUy1iYXNlZCBPZmYgKFRyYXZpcyBBVEcpCi0gKiAgICAgYml0IDMgICAgIEF1dG86IEFMUy0gYW5kIGlucHV0LWFjdGl2aXR5LWJhc2VkIE9uOyBpbnB1dC1hY3Rpdml0eSBiYXNlZCBPZmYKLSAqICAgICBiaXQgNCAgICAgQXV0bzogSW5wdXQtYWN0aXZpdHktYmFzZWQgT247IGlucHV0LWFjdGl2aXR5IGJhc2VkIE9mZgotICogICAgIGJpdCA1ICAgICBBdXRvOiBJbnB1dC1hY3Rpdml0eS1iYXNlZCBPbiAoaWxsdW1pbmF0aW9uIGxldmVsIDI1JSk7IGlucHV0LWFjdGl2aXR5IGJhc2VkIE9mZgotICogICAgIGJpdCA2ICAgICBBdXRvOiBJbnB1dC1hY3Rpdml0eS1iYXNlZCBPbiAoaWxsdW1pbmF0aW9uIGxldmVsIDUwJSk7IGlucHV0LWFjdGl2aXR5IGJhc2VkIE9mZgotICogICAgIGJpdCA3ICAgICBBdXRvOiBJbnB1dC1hY3Rpdml0eS1iYXNlZCBPbiAoaWxsdW1pbmF0aW9uIGxldmVsIDc1JSk7IGlucHV0LWFjdGl2aXR5IGJhc2VkIE9mZgotICogICAgIGJpdCA4ICAgICBBdXRvOiBJbnB1dC1hY3Rpdml0eS1iYXNlZCBPbiAoaWxsdW1pbmF0aW9uIGxldmVsIDEwMCUpOyBpbnB1dC1hY3Rpdml0eSBiYXNlZCBPZmYKLSAqICAgICBiaXRzIDktMTUgUmVzZXJ2ZWQgZm9yIGZ1dHVyZSB1c2UKLSAqICAgICBOb3RlOiBPbmx5IE9uZSBiaXQgY2FuIGJlIHNldAotICogIGNiUkVTMiwgYnl0ZTIgIEN1cnJlbnRseSBhY3RpdmUgYXV0byBrZXlib2FyZCBpbGx1bWluYXRpb24gdHJpZ2dlcnMuCi0gKiAgICAgYml0IDAgICAgIEFueSBrZXlzdHJva2UKLSAqICAgICBiaXQgMSAgICAgVG91Y2hwYWQgYWN0aXZpdHkKLSAqICAgICBiaXQgMiAgICAgUG9pbnRpbmcgc3RpY2sKLSAqICAgICBiaXQgMyAgICAgQW55IG1vdXNlCi0gKiAgICAgYml0cyA0LTcgIFJlc2VydmVkIGZvciBmdXR1cmUgdXNlCi0gKiAgY2JSRVMyLCBieXRlMyAgQ3VycmVudCBUaW1lb3V0Ci0gKiAgICAgYml0cyA3OjYgIFRpbWVvdXQgdW5pdHMgaW5kaWNhdG9yOgotICogICAgIDAwYiAgICAgICBTZWNvbmRzCi0gKiAgICAgMDFiICAgICAgIE1pbnV0ZXMKLSAqICAgICAxMGIgICAgICAgSG91cnMKLSAqICAgICAxMWIgICAgICAgRGF5cwotICogICAgIGJpdHMgNTowICBUaW1lb3V0IHZhbHVlICgwLTYzKSBpbiBzZWMvbWluL2hyL2RheQotICogICAgIE5PVEU6IEEgdmFsdWUgb2YgMCBtZWFucyBhbHdheXMgb24gKG5vIHRpbWVvdXQpIGlmIGFueSBiaXRzIG9mIFJFUzMgYnl0ZQotICogICAgIGFyZSBzZXQgdXBvbiByZXR1cm4gZnJvbSB0aGUgW0dldCBmZWF0dXJlIGluZm9ybWF0aW9uXSBjYWxsLgotICogIGNiUkVTMywgYnl0ZTAgIEN1cnJlbnQgc2V0dGluZyBvZiBBTFMgdmFsdWUgdGhhdCB0dXJucyB0aGUgbGlnaHQgb24gb3Igb2ZmLgotICogIGNiUkVTMywgYnl0ZTEgIEN1cnJlbnQgQUxTIHJlYWRpbmcKLSAqICBjYlJFUzMsIGJ5dGUyICBDdXJyZW50IGtleWJvYXJkIGxpZ2h0IGxldmVsLgotICoKLSAqIGNiQXJnMSAweDIgPSBTZXQgTmV3IFN0YXRlCi0gKiAgY2JSRVMxICAgICAgICAgU3RhbmRhcmQgcmV0dXJuIGNvZGVzICgwLCAtMSwgLTIpCi0gKiAgY2JBcmcyLCB3b3JkMCAgQml0bWFwIG9mIGN1cnJlbnQgbW9kZSBzdGF0ZQotICogICAgIGJpdCAwICAgICBBbHdheXMgb2ZmIChBbGwgc3lzdGVtcykKLSAqICAgICBiaXQgMSAgICAgQWx3YXlzIG9uIChUcmF2aXMgQVRHLCBTaWJlcmlhKQotICogICAgIGJpdCAyICAgICBBdXRvOiBBTFMtYmFzZWQgT247IEFMUy1iYXNlZCBPZmYgKFRyYXZpcyBBVEcpCi0gKiAgICAgYml0IDMgICAgIEF1dG86IEFMUy0gYW5kIGlucHV0LWFjdGl2aXR5LWJhc2VkIE9uOyBpbnB1dC1hY3Rpdml0eSBiYXNlZCBPZmYKLSAqICAgICBiaXQgNCAgICAgQXV0bzogSW5wdXQtYWN0aXZpdHktYmFzZWQgT247IGlucHV0LWFjdGl2aXR5IGJhc2VkIE9mZgotICogICAgIGJpdCA1ICAgICBBdXRvOiBJbnB1dC1hY3Rpdml0eS1iYXNlZCBPbiAoaWxsdW1pbmF0aW9uIGxldmVsIDI1JSk7IGlucHV0LWFjdGl2aXR5IGJhc2VkIE9mZgotICogICAgIGJpdCA2ICAgICBBdXRvOiBJbnB1dC1hY3Rpdml0eS1iYXNlZCBPbiAoaWxsdW1pbmF0aW9uIGxldmVsIDUwJSk7IGlucHV0LWFjdGl2aXR5IGJhc2VkIE9mZgotICogICAgIGJpdCA3ICAgICBBdXRvOiBJbnB1dC1hY3Rpdml0eS1iYXNlZCBPbiAoaWxsdW1pbmF0aW9uIGxldmVsIDc1JSk7IGlucHV0LWFjdGl2aXR5IGJhc2VkIE9mZgotICogICAgIGJpdCA4ICAgICBBdXRvOiBJbnB1dC1hY3Rpdml0eS1iYXNlZCBPbiAoaWxsdW1pbmF0aW9uIGxldmVsIDEwMCUpOyBpbnB1dC1hY3Rpdml0eSBiYXNlZCBPZmYKLSAqICAgICBiaXRzIDktMTUgUmVzZXJ2ZWQgZm9yIGZ1dHVyZSB1c2UKLSAqICAgICBOb3RlOiBPbmx5IE9uZSBiaXQgY2FuIGJlIHNldAotICogIGNiQXJnMiwgYnl0ZTIgIERlc2lyZWQgYXV0byBrZXlib2FyZCBpbGx1bWluYXRpb24gdHJpZ2dlcnMuIE11c3QgcmVtYWluIGluYWN0aXZlIHRvIGFsbG93Ci0gKiAgICAgICAgICAgICAgICAga2V5Ym9hcmQgdG8gdHVybiBvZmYgYXV0b21hdGljYWxseS4KLSAqICAgICBiaXQgMCAgICAgQW55IGtleXN0cm9rZQotICogICAgIGJpdCAxICAgICBUb3VjaHBhZCBhY3Rpdml0eQotICogICAgIGJpdCAyICAgICBQb2ludGluZyBzdGljawotICogICAgIGJpdCAzICAgICBBbnkgbW91c2UKLSAqICAgICBiaXRzIDQtNyAgUmVzZXJ2ZWQgZm9yIGZ1dHVyZSB1c2UKLSAqICBjYkFyZzIsIGJ5dGUzICBEZXNpcmVkIFRpbWVvdXQKLSAqICAgICBiaXRzIDc6NiAgVGltZW91dCB1bml0cyBpbmRpY2F0b3I6Ci0gKiAgICAgMDBiICAgICAgIFNlY29uZHMKLSAqICAgICAwMWIgICAgICAgTWludXRlcwotICogICAgIDEwYiAgICAgICBIb3VycwotICogICAgIDExYiAgICAgICBEYXlzCi0gKiAgICAgYml0cyA1OjAgIFRpbWVvdXQgdmFsdWUgKDAtNjMpIGluIHNlYy9taW4vaHIvZGF5Ci0gKiAgY2JBcmczLCBieXRlMCAgRGVzaXJlZCBzZXR0aW5nIG9mIEFMUyB2YWx1ZSB0aGF0IHR1cm5zIHRoZSBsaWdodCBvbiBvciBvZmYuCi0gKiAgY2JBcmczLCBieXRlMiAgRGVzaXJlZCBrZXlib2FyZCBsaWdodCBsZXZlbC4KLSAqLwotCi0KLWVudW0ga2JkX3RpbWVvdXRfdW5pdCB7Ci0JS0JEX1RJTUVPVVRfU0VDT05EUyA9IDAsCi0JS0JEX1RJTUVPVVRfTUlOVVRFUywKLQlLQkRfVElNRU9VVF9IT1VSUywKLQlLQkRfVElNRU9VVF9EQVlTLAotfTsKLQotZW51bSBrYmRfbW9kZV9iaXQgewotCUtCRF9NT0RFX0JJVF9PRkYgPSAwLAotCUtCRF9NT0RFX0JJVF9PTiwKLQlLQkRfTU9ERV9CSVRfQUxTLAotCUtCRF9NT0RFX0JJVF9UUklHR0VSX0FMUywKLQlLQkRfTU9ERV9CSVRfVFJJR0dFUiwKLQlLQkRfTU9ERV9CSVRfVFJJR0dFUl8yNSwKLQlLQkRfTU9ERV9CSVRfVFJJR0dFUl81MCwKLQlLQkRfTU9ERV9CSVRfVFJJR0dFUl83NSwKLQlLQkRfTU9ERV9CSVRfVFJJR0dFUl8xMDAsCi19OwotCi0jZGVmaW5lIGtiZF9pc19hbHNfbW9kZV9iaXQoYml0KSBcCi0JKChiaXQpID09IEtCRF9NT0RFX0JJVF9BTFMgfHwgKGJpdCkgPT0gS0JEX01PREVfQklUX1RSSUdHRVJfQUxTKQotI2RlZmluZSBrYmRfaXNfdHJpZ2dlcl9tb2RlX2JpdChiaXQpIFwKLQkoKGJpdCkgPj0gS0JEX01PREVfQklUX1RSSUdHRVJfQUxTICYmIChiaXQpIDw9IEtCRF9NT0RFX0JJVF9UUklHR0VSXzEwMCkKLSNkZWZpbmUga2JkX2lzX2xldmVsX21vZGVfYml0KGJpdCkgXAotCSgoYml0KSA+PSBLQkRfTU9ERV9CSVRfVFJJR0dFUl8yNSAmJiAoYml0KSA8PSBLQkRfTU9ERV9CSVRfVFJJR0dFUl8xMDApCi0KLXN0cnVjdCBrYmRfaW5mbyB7Ci0JdTE2IG1vZGVzOwotCXU4IHR5cGU7Ci0JdTggdHJpZ2dlcnM7Ci0JdTggbGV2ZWxzOwotCXU4IHNlY29uZHM7Ci0JdTggbWludXRlczsKLQl1OCBob3VyczsKLQl1OCBkYXlzOwotfTsKLQotc3RydWN0IGtiZF9zdGF0ZSB7Ci0JdTggbW9kZV9iaXQ7Ci0JdTggdHJpZ2dlcnM7Ci0JdTggdGltZW91dF92YWx1ZTsKLQl1OCB0aW1lb3V0X3VuaXQ7Ci0JdTggYWxzX3NldHRpbmc7Ci0JdTggYWxzX3ZhbHVlOwotCXU4IGxldmVsOwotfTsKLQotc3RhdGljIGNvbnN0IGludCBrYmRfdG9rZW5zW10gPSB7Ci0JS0JEX0xFRF9PRkZfVE9LRU4sCi0JS0JEX0xFRF9BVVRPXzI1X1RPS0VOLAotCUtCRF9MRURfQVVUT181MF9UT0tFTiwKLQlLQkRfTEVEX0FVVE9fNzVfVE9LRU4sCi0JS0JEX0xFRF9BVVRPXzEwMF9UT0tFTiwKLQlLQkRfTEVEX09OX1RPS0VOLAotfTsKLQotc3RhdGljIHUxNiBrYmRfdG9rZW5fYml0czsKLQotc3RhdGljIHN0cnVjdCBrYmRfaW5mbyBrYmRfaW5mbzsKLXN0YXRpYyBib29sIGtiZF9hbHNfc3VwcG9ydGVkOwotc3RhdGljIGJvb2wga2JkX3RyaWdnZXJzX3N1cHBvcnRlZDsKLQotc3RhdGljIHU4IGtiZF9tb2RlX2xldmVsc1sxNl07Ci1zdGF0aWMgaW50IGtiZF9tb2RlX2xldmVsc19jb3VudDsKLQotc3RhdGljIHU4IGtiZF9wcmV2aW91c19sZXZlbDsKLXN0YXRpYyB1OCBrYmRfcHJldmlvdXNfbW9kZV9iaXQ7Ci0KLXN0YXRpYyBib29sIGtiZF9sZWRfcHJlc2VudDsKLQotLyoKLSAqIE5PVEU6IHRoZXJlIGFyZSB0aHJlZSB3YXlzIHRvIHNldCB0aGUga2V5Ym9hcmQgYmFja2xpZ2h0IGxldmVsLgotICogRmlyc3QsIHZpYSBrYmRfc3RhdGUubW9kZV9iaXQgKGFzc2lnbmluZyBLQkRfTU9ERV9CSVRfVFJJR0dFUl8qIHZhbHVlKS4KLSAqIFNlY29uZCwgdmlhIGtiZF9zdGF0ZS5sZXZlbCAoYXNzaWduaW5nIG51bWVyaWNhbCB2YWx1ZSA8PSBrYmRfaW5mby5sZXZlbHMpLgotICogVGhpcmQsIHZpYSBTTUJJT1MgdG9rZW5zIChLQkRfTEVEXyogaW4ga2JkX3Rva2VucykKLSAqCi0gKiBUaGVyZSBhcmUgbGFwdG9wcyB3aGljaCBzdXBwb3J0IG9ubHkgb25lIG9mIHRoZXNlIG1ldGhvZHMuIElmIHdlIHdhbnQgdG8KLSAqIHN1cHBvcnQgYXMgbWFueSBtYWNoaW5lcyBhcyBwb3NzaWJsZSB3ZSBuZWVkIHRvIGltcGxlbWVudCBhbGwgdGhyZWUgbWV0aG9kcy4KLSAqIFRoZSBmaXJzdCB0d28gbWV0aG9kcyB1c2UgdGhlIGtiZF9zdGF0ZSBzdHJ1Y3R1cmUuIFRoZSB0aGlyZCB1c2VzIFNNQklPUwotICogdG9rZW5zLiBJZiBrYmRfaW5mby5sZXZlbHMgPT0gMCwgdGhlIG1hY2hpbmUgZG9lcyBub3Qgc3VwcG9ydCBzZXR0aW5nIHRoZQotICoga2V5Ym9hcmQgYmFja2xpZ2h0IGxldmVsIHZpYSBrYmRfc3RhdGUubGV2ZWwuCi0gKi8KLQotc3RhdGljIGludCBrYmRfZ2V0X2luZm8oc3RydWN0IGtiZF9pbmZvICppbmZvKQotewotCXU4IHVuaXRzOwotCWludCByZXQ7Ci0KLQlnZXRfYnVmZmVyKCk7Ci0KLQlidWZmZXItPmlucHV0WzBdID0gMHgwOwotCWRlbGxfc2VuZF9yZXF1ZXN0KGJ1ZmZlciwgNCwgMTEpOwotCXJldCA9IGJ1ZmZlci0+b3V0cHV0WzBdOwotCi0JaWYgKHJldCkgewotCQlyZXQgPSBkZWxsX3NtaV9lcnJvcihyZXQpOwotCQlnb3RvIG91dDsKLQl9Ci0KLQlpbmZvLT5tb2RlcyA9IGJ1ZmZlci0+b3V0cHV0WzFdICYgMHhGRkZGOwotCWluZm8tPnR5cGUgPSAoYnVmZmVyLT5vdXRwdXRbMV0gPj4gMjQpICYgMHhGRjsKLQlpbmZvLT50cmlnZ2VycyA9IGJ1ZmZlci0+b3V0cHV0WzJdICYgMHhGRjsKLQl1bml0cyA9IChidWZmZXItPm91dHB1dFsyXSA+PiA4KSAmIDB4RkY7Ci0JaW5mby0+bGV2ZWxzID0gKGJ1ZmZlci0+b3V0cHV0WzJdID4+IDE2KSAmIDB4RkY7Ci0KLQlpZiAodW5pdHMgJiBCSVQoMCkpCi0JCWluZm8tPnNlY29uZHMgPSAoYnVmZmVyLT5vdXRwdXRbM10gPj4gMCkgJiAweEZGOwotCWlmICh1bml0cyAmIEJJVCgxKSkKLQkJaW5mby0+bWludXRlcyA9IChidWZmZXItPm91dHB1dFszXSA+PiA4KSAmIDB4RkY7Ci0JaWYgKHVuaXRzICYgQklUKDIpKQotCQlpbmZvLT5ob3VycyA9IChidWZmZXItPm91dHB1dFszXSA+PiAxNikgJiAweEZGOwotCWlmICh1bml0cyAmIEJJVCgzKSkKLQkJaW5mby0+ZGF5cyA9IChidWZmZXItPm91dHB1dFszXSA+PiAyNCkgJiAweEZGOwotCi0gb3V0OgotCXJlbGVhc2VfYnVmZmVyKCk7Ci0JcmV0dXJuIHJldDsKLX0KLQotc3RhdGljIHVuc2lnbmVkIGludCBrYmRfZ2V0X21heF9sZXZlbCh2b2lkKQotewotCWlmIChrYmRfaW5mby5sZXZlbHMgIT0gMCkKLQkJcmV0dXJuIGtiZF9pbmZvLmxldmVsczsKLQlpZiAoa2JkX21vZGVfbGV2ZWxzX2NvdW50ID4gMCkKLQkJcmV0dXJuIGtiZF9tb2RlX2xldmVsc19jb3VudCAtIDE7Ci0JcmV0dXJuIDA7Ci19Ci0KLXN0YXRpYyBpbnQga2JkX2dldF9sZXZlbChzdHJ1Y3Qga2JkX3N0YXRlICpzdGF0ZSkKLXsKLQlpbnQgaTsKLQotCWlmIChrYmRfaW5mby5sZXZlbHMgIT0gMCkKLQkJcmV0dXJuIHN0YXRlLT5sZXZlbDsKLQotCWlmIChrYmRfbW9kZV9sZXZlbHNfY291bnQgPiAwKSB7Ci0JCWZvciAoaSA9IDA7IGkgPCBrYmRfbW9kZV9sZXZlbHNfY291bnQ7ICsraSkKLQkJCWlmIChrYmRfbW9kZV9sZXZlbHNbaV0gPT0gc3RhdGUtPm1vZGVfYml0KQotCQkJCXJldHVybiBpOwotCQlyZXR1cm4gMDsKLQl9Ci0KLQlyZXR1cm4gLUVJTlZBTDsKLX0KLQotc3RhdGljIGludCBrYmRfc2V0X2xldmVsKHN0cnVjdCBrYmRfc3RhdGUgKnN0YXRlLCB1OCBsZXZlbCkKLXsKLQlpZiAoa2JkX2luZm8ubGV2ZWxzICE9IDApIHsKLQkJaWYgKGxldmVsICE9IDApCi0JCQlrYmRfcHJldmlvdXNfbGV2ZWwgPSBsZXZlbDsKLQkJaWYgKHN0YXRlLT5sZXZlbCA9PSBsZXZlbCkKLQkJCXJldHVybiAwOwotCQlzdGF0ZS0+bGV2ZWwgPSBsZXZlbDsKLQkJaWYgKGxldmVsICE9IDAgJiYgc3RhdGUtPm1vZGVfYml0ID09IEtCRF9NT0RFX0JJVF9PRkYpCi0JCQlzdGF0ZS0+bW9kZV9iaXQgPSBrYmRfcHJldmlvdXNfbW9kZV9iaXQ7Ci0JCWVsc2UgaWYgKGxldmVsID09IDAgJiYgc3RhdGUtPm1vZGVfYml0ICE9IEtCRF9NT0RFX0JJVF9PRkYpIHsKLQkJCWtiZF9wcmV2aW91c19tb2RlX2JpdCA9IHN0YXRlLT5tb2RlX2JpdDsKLQkJCXN0YXRlLT5tb2RlX2JpdCA9IEtCRF9NT0RFX0JJVF9PRkY7Ci0JCX0KLQkJcmV0dXJuIDA7Ci0JfQotCi0JaWYgKGtiZF9tb2RlX2xldmVsc19jb3VudCA+IDAgJiYgbGV2ZWwgPCBrYmRfbW9kZV9sZXZlbHNfY291bnQpIHsKLQkJaWYgKGxldmVsICE9IDApCi0JCQlrYmRfcHJldmlvdXNfbGV2ZWwgPSBsZXZlbDsKLQkJc3RhdGUtPm1vZGVfYml0ID0ga2JkX21vZGVfbGV2ZWxzW2xldmVsXTsKLQkJcmV0dXJuIDA7Ci0JfQotCi0JcmV0dXJuIC1FSU5WQUw7Ci19Ci0KLXN0YXRpYyBpbnQga2JkX2dldF9zdGF0ZShzdHJ1Y3Qga2JkX3N0YXRlICpzdGF0ZSkKLXsKLQlpbnQgcmV0OwotCi0JZ2V0X2J1ZmZlcigpOwotCi0JYnVmZmVyLT5pbnB1dFswXSA9IDB4MTsKLQlkZWxsX3NlbmRfcmVxdWVzdChidWZmZXIsIDQsIDExKTsKLQlyZXQgPSBidWZmZXItPm91dHB1dFswXTsKLQotCWlmIChyZXQpIHsKLQkJcmV0ID0gZGVsbF9zbWlfZXJyb3IocmV0KTsKLQkJZ290byBvdXQ7Ci0JfQotCi0Jc3RhdGUtPm1vZGVfYml0ID0gZmZzKGJ1ZmZlci0+b3V0cHV0WzFdICYgMHhGRkZGKTsKLQlpZiAoc3RhdGUtPm1vZGVfYml0ICE9IDApCi0JCXN0YXRlLT5tb2RlX2JpdC0tOwotCi0Jc3RhdGUtPnRyaWdnZXJzID0gKGJ1ZmZlci0+b3V0cHV0WzFdID4+IDE2KSAmIDB4RkY7Ci0Jc3RhdGUtPnRpbWVvdXRfdmFsdWUgPSAoYnVmZmVyLT5vdXRwdXRbMV0gPj4gMjQpICYgMHgzRjsKLQlzdGF0ZS0+dGltZW91dF91bml0ID0gKGJ1ZmZlci0+b3V0cHV0WzFdID4+IDMwKSAmIDB4MzsKLQlzdGF0ZS0+YWxzX3NldHRpbmcgPSBidWZmZXItPm91dHB1dFsyXSAmIDB4RkY7Ci0Jc3RhdGUtPmFsc192YWx1ZSA9IChidWZmZXItPm91dHB1dFsyXSA+PiA4KSAmIDB4RkY7Ci0Jc3RhdGUtPmxldmVsID0gKGJ1ZmZlci0+b3V0cHV0WzJdID4+IDE2KSAmIDB4RkY7Ci0KLSBvdXQ6Ci0JcmVsZWFzZV9idWZmZXIoKTsKLQlyZXR1cm4gcmV0OwotfQotCi1zdGF0aWMgaW50IGtiZF9zZXRfc3RhdGUoc3RydWN0IGtiZF9zdGF0ZSAqc3RhdGUpCi17Ci0JaW50IHJldDsKLQotCWdldF9idWZmZXIoKTsKLQlidWZmZXItPmlucHV0WzBdID0gMHgyOwotCWJ1ZmZlci0+aW5wdXRbMV0gPSBCSVQoc3RhdGUtPm1vZGVfYml0KSAmIDB4RkZGRjsKLQlidWZmZXItPmlucHV0WzFdIHw9IChzdGF0ZS0+dHJpZ2dlcnMgJiAweEZGKSA8PCAxNjsKLQlidWZmZXItPmlucHV0WzFdIHw9IChzdGF0ZS0+dGltZW91dF92YWx1ZSAmIDB4M0YpIDw8IDI0OwotCWJ1ZmZlci0+aW5wdXRbMV0gfD0gKHN0YXRlLT50aW1lb3V0X3VuaXQgJiAweDMpIDw8IDMwOwotCWJ1ZmZlci0+aW5wdXRbMl0gPSBzdGF0ZS0+YWxzX3NldHRpbmcgJiAweEZGOwotCWJ1ZmZlci0+aW5wdXRbMl0gfD0gKHN0YXRlLT5sZXZlbCAmIDB4RkYpIDw8IDE2OwotCWRlbGxfc2VuZF9yZXF1ZXN0KGJ1ZmZlciwgNCwgMTEpOwotCXJldCA9IGJ1ZmZlci0+b3V0cHV0WzBdOwotCXJlbGVhc2VfYnVmZmVyKCk7Ci0KLQlyZXR1cm4gZGVsbF9zbWlfZXJyb3IocmV0KTsKLX0KLQotc3RhdGljIGludCBrYmRfc2V0X3N0YXRlX3NhZmUoc3RydWN0IGtiZF9zdGF0ZSAqc3RhdGUsIHN0cnVjdCBrYmRfc3RhdGUgKm9sZCkKLXsKLQlpbnQgcmV0OwotCi0JcmV0ID0ga2JkX3NldF9zdGF0ZShzdGF0ZSk7Ci0JaWYgKHJldCA9PSAwKQotCQlyZXR1cm4gMDsKLQotCS8qCi0JICogV2hlbiBzZXR0aW5nIHRoZSBuZXcgc3RhdGUgZmFpbHMsdHJ5IHRvIHJlc3RvcmUgdGhlIHByZXZpb3VzIG9uZS4KLQkgKiBUaGlzIGlzIG5lZWRlZCBvbiBzb21lIG1hY2hpbmVzIHdoZXJlIEJJT1Mgc2V0cyBhIGRlZmF1bHQgc3RhdGUgd2hlbgotCSAqIHNldHRpbmcgYSBuZXcgc3RhdGUgZmFpbHMuIFRoaXMgZGVmYXVsdCBzdGF0ZSBjb3VsZCBiZSBhbGwgb2ZmLgotCSAqLwotCi0JaWYgKGtiZF9zZXRfc3RhdGUob2xkKSkKLQkJcHJfZXJyKCJTZXR0aW5nIG9sZCBwcmV2aW91cyBrZXlib2FyZCBzdGF0ZSBmYWlsZWRcbiIpOwotCi0JcmV0dXJuIHJldDsKLX0KLQotc3RhdGljIGludCBrYmRfc2V0X3Rva2VuX2JpdCh1OCBiaXQpCi17Ci0JaW50IGlkOwotCWludCByZXQ7Ci0KLQlpZiAoYml0ID49IEFSUkFZX1NJWkUoa2JkX3Rva2VucykpCi0JCXJldHVybiAtRUlOVkFMOwotCi0JaWQgPSBmaW5kX3Rva2VuX2lkKGtiZF90b2tlbnNbYml0XSk7Ci0JaWYgKGlkID09IC0xKQotCQlyZXR1cm4gLUVJTlZBTDsKLQotCWdldF9idWZmZXIoKTsKLQlidWZmZXItPmlucHV0WzBdID0gZGFfdG9rZW5zW2lkXS5sb2NhdGlvbjsKLQlidWZmZXItPmlucHV0WzFdID0gZGFfdG9rZW5zW2lkXS52YWx1ZTsKLQlkZWxsX3NlbmRfcmVxdWVzdChidWZmZXIsIDEsIDApOwotCXJldCA9IGJ1ZmZlci0+b3V0cHV0WzBdOwotCXJlbGVhc2VfYnVmZmVyKCk7Ci0KLQlyZXR1cm4gZGVsbF9zbWlfZXJyb3IocmV0KTsKLX0KLQotc3RhdGljIGludCBrYmRfZ2V0X3Rva2VuX2JpdCh1OCBiaXQpCi17Ci0JaW50IGlkOwotCWludCByZXQ7Ci0JaW50IHZhbDsKLQotCWlmIChiaXQgPj0gQVJSQVlfU0laRShrYmRfdG9rZW5zKSkKLQkJcmV0dXJuIC1FSU5WQUw7Ci0KLQlpZCA9IGZpbmRfdG9rZW5faWQoa2JkX3Rva2Vuc1tiaXRdKTsKLQlpZiAoaWQgPT0gLTEpCi0JCXJldHVybiAtRUlOVkFMOwotCi0JZ2V0X2J1ZmZlcigpOwotCWJ1ZmZlci0+aW5wdXRbMF0gPSBkYV90b2tlbnNbaWRdLmxvY2F0aW9uOwotCWRlbGxfc2VuZF9yZXF1ZXN0KGJ1ZmZlciwgMCwgMCk7Ci0JcmV0ID0gYnVmZmVyLT5vdXRwdXRbMF07Ci0JdmFsID0gYnVmZmVyLT5vdXRwdXRbMV07Ci0JcmVsZWFzZV9idWZmZXIoKTsKLQotCWlmIChyZXQpCi0JCXJldHVybiBkZWxsX3NtaV9lcnJvcihyZXQpOwotCi0JcmV0dXJuICh2YWwgPT0gZGFfdG9rZW5zW2lkXS52YWx1ZSk7Ci19Ci0KLXN0YXRpYyBpbnQga2JkX2dldF9maXJzdF9hY3RpdmVfdG9rZW5fYml0KHZvaWQpCi17Ci0JaW50IGk7Ci0JaW50IHJldDsKLQotCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKGtiZF90b2tlbnMpOyArK2kpIHsKLQkJcmV0ID0ga2JkX2dldF90b2tlbl9iaXQoaSk7Ci0JCWlmIChyZXQgPT0gMSkKLQkJCXJldHVybiBpOwotCX0KLQotCXJldHVybiByZXQ7Ci19Ci0KLXN0YXRpYyBpbnQga2JkX2dldF92YWxpZF90b2tlbl9jb3VudHModm9pZCkKLXsKLQlyZXR1cm4gaHdlaWdodDE2KGtiZF90b2tlbl9iaXRzKTsKLX0KLQotc3RhdGljIGlubGluZSBpbnQga2JkX2luaXRfaW5mbyh2b2lkKQotewotCXN0cnVjdCBrYmRfc3RhdGUgc3RhdGU7Ci0JaW50IHJldDsKLQlpbnQgaTsKLQotCXJldCA9IGtiZF9nZXRfaW5mbygma2JkX2luZm8pOwotCWlmIChyZXQpCi0JCXJldHVybiByZXQ7Ci0KLQlrYmRfZ2V0X3N0YXRlKCZzdGF0ZSk7Ci0KLQkvKiBOT1RFOiB0aW1lb3V0IHZhbHVlIGlzIHN0b3JlZCBpbiA2IGJpdHMgc28gbWF4IHZhbHVlIGlzIDYzICovCi0JaWYgKGtiZF9pbmZvLnNlY29uZHMgPiA2MykKLQkJa2JkX2luZm8uc2Vjb25kcyA9IDYzOwotCWlmIChrYmRfaW5mby5taW51dGVzID4gNjMpCi0JCWtiZF9pbmZvLm1pbnV0ZXMgPSA2MzsKLQlpZiAoa2JkX2luZm8uaG91cnMgPiA2MykKLQkJa2JkX2luZm8uaG91cnMgPSA2MzsKLQlpZiAoa2JkX2luZm8uZGF5cyA+IDYzKQotCQlrYmRfaW5mby5kYXlzID0gNjM7Ci0KLQkvKiBOT1RFOiBPbiB0ZXN0ZWQgbWFjaGluZXMgT04gbW9kZSBkaWQgbm90IHdvcmsgYW5kIGNhdXNlZAotCSAqICAgICAgIHByb2JsZW1zICh0dXJuZWQgYmFja2xpZ2h0IG9mZikgc28gZG8gbm90IHVzZSBpdAotCSAqLwotCWtiZF9pbmZvLm1vZGVzICY9IH5CSVQoS0JEX01PREVfQklUX09OKTsKLQotCWtiZF9wcmV2aW91c19sZXZlbCA9IGtiZF9nZXRfbGV2ZWwoJnN0YXRlKTsKLQlrYmRfcHJldmlvdXNfbW9kZV9iaXQgPSBzdGF0ZS5tb2RlX2JpdDsKLQotCWlmIChrYmRfcHJldmlvdXNfbGV2ZWwgPT0gMCAmJiBrYmRfZ2V0X21heF9sZXZlbCgpICE9IDApCi0JCWtiZF9wcmV2aW91c19sZXZlbCA9IDE7Ci0KLQlpZiAoa2JkX3ByZXZpb3VzX21vZGVfYml0ID09IEtCRF9NT0RFX0JJVF9PRkYpIHsKLQkJa2JkX3ByZXZpb3VzX21vZGVfYml0ID0KLQkJCWZmcyhrYmRfaW5mby5tb2RlcyAmIH5CSVQoS0JEX01PREVfQklUX09GRikpOwotCQlpZiAoa2JkX3ByZXZpb3VzX21vZGVfYml0ICE9IDApCi0JCQlrYmRfcHJldmlvdXNfbW9kZV9iaXQtLTsKLQl9Ci0KLQlpZiAoa2JkX2luZm8ubW9kZXMgJiAoQklUKEtCRF9NT0RFX0JJVF9BTFMpIHwKLQkJCSAgICAgIEJJVChLQkRfTU9ERV9CSVRfVFJJR0dFUl9BTFMpKSkKLQkJa2JkX2Fsc19zdXBwb3J0ZWQgPSB0cnVlOwotCi0JaWYgKGtiZF9pbmZvLm1vZGVzICYgKAotCSAgICBCSVQoS0JEX01PREVfQklUX1RSSUdHRVJfQUxTKSB8IEJJVChLQkRfTU9ERV9CSVRfVFJJR0dFUikgfAotCSAgICBCSVQoS0JEX01PREVfQklUX1RSSUdHRVJfMjUpIHwgQklUKEtCRF9NT0RFX0JJVF9UUklHR0VSXzUwKSB8Ci0JICAgIEJJVChLQkRfTU9ERV9CSVRfVFJJR0dFUl83NSkgfCBCSVQoS0JEX01PREVfQklUX1RSSUdHRVJfMTAwKQotCSAgICkpCi0JCWtiZF90cmlnZ2Vyc19zdXBwb3J0ZWQgPSB0cnVlOwotCi0JLyoga2JkX21vZGVfbGV2ZWxzWzBdIGlzIHJlc2VydmVkLCBzZWUgYmVsb3cgKi8KLQlmb3IgKGkgPSAwOyBpIDwgMTY7ICsraSkKLQkJaWYgKGtiZF9pc19sZXZlbF9tb2RlX2JpdChpKSAmJiAoQklUKGkpICYga2JkX2luZm8ubW9kZXMpKQotCQkJa2JkX21vZGVfbGV2ZWxzWzEgKyBrYmRfbW9kZV9sZXZlbHNfY291bnQrK10gPSBpOwotCi0JLyoKLQkgKiBGaW5kIHRoZSBmaXJzdCBzdXBwb3J0ZWQgbW9kZSBhbmQgYXNzaWduIHRvIGtiZF9tb2RlX2xldmVsc1swXS4KLQkgKiBUaGlzIHNob3VsZCBiZSAwIChvZmYpLCBidXQgd2UgY2Fubm90IGRlcGVuZCBvbiB0aGUgQklPUyB0bwotCSAqIHN1cHBvcnQgMC4KLQkgKi8KLQlpZiAoa2JkX21vZGVfbGV2ZWxzX2NvdW50ID4gMCkgewotCQlmb3IgKGkgPSAwOyBpIDwgMTY7ICsraSkgewotCQkJaWYgKEJJVChpKSAmIGtiZF9pbmZvLm1vZGVzKSB7Ci0JCQkJa2JkX21vZGVfbGV2ZWxzWzBdID0gaTsKLQkJCQlicmVhazsKLQkJCX0KLQkJfQotCQlrYmRfbW9kZV9sZXZlbHNfY291bnQrKzsKLQl9Ci0KLQlyZXR1cm4gMDsKLQotfQotCi1zdGF0aWMgaW5saW5lIHZvaWQga2JkX2luaXRfdG9rZW5zKHZvaWQpCi17Ci0JaW50IGk7Ci0KLQlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShrYmRfdG9rZW5zKTsgKytpKQotCQlpZiAoZmluZF90b2tlbl9pZChrYmRfdG9rZW5zW2ldKSAhPSAtMSkKLQkJCWtiZF90b2tlbl9iaXRzIHw9IEJJVChpKTsKLX0KLQotc3RhdGljIHZvaWQga2JkX2luaXQodm9pZCkKLXsKLQlpbnQgcmV0OwotCi0JcmV0ID0ga2JkX2luaXRfaW5mbygpOwotCWtiZF9pbml0X3Rva2VucygpOwotCi0JaWYgKGtiZF90b2tlbl9iaXRzICE9IDAgfHwgcmV0ID09IDApCi0JCWtiZF9sZWRfcHJlc2VudCA9IHRydWU7Ci19Ci0KLXN0YXRpYyBzc2l6ZV90IGtiZF9sZWRfdGltZW91dF9zdG9yZShzdHJ1Y3QgZGV2aWNlICpkZXYsCi0JCQkJICAgICBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKLQkJCQkgICAgIGNvbnN0IGNoYXIgKmJ1Ziwgc2l6ZV90IGNvdW50KQotewotCXN0cnVjdCBrYmRfc3RhdGUgbmV3X3N0YXRlOwotCXN0cnVjdCBrYmRfc3RhdGUgc3RhdGU7Ci0JYm9vbCBjb252ZXJ0OwotCWludCB2YWx1ZTsKLQlpbnQgcmV0OwotCWNoYXIgY2g7Ci0JdTggdW5pdDsKLQlpbnQgaTsKLQotCXJldCA9IHNzY2FuZihidWYsICIlZCAlYyIsICZ2YWx1ZSwgJmNoKTsKLQlpZiAocmV0IDwgMSkKLQkJcmV0dXJuIC1FSU5WQUw7Ci0JZWxzZSBpZiAocmV0ID09IDEpCi0JCWNoID0gJ3MnOwotCi0JaWYgKHZhbHVlIDwgMCkKLQkJcmV0dXJuIC1FSU5WQUw7Ci0KLQljb252ZXJ0ID0gZmFsc2U7Ci0KLQlzd2l0Y2ggKGNoKSB7Ci0JY2FzZSAncyc6Ci0JCWlmICh2YWx1ZSA+IGtiZF9pbmZvLnNlY29uZHMpCi0JCQljb252ZXJ0ID0gdHJ1ZTsKLQkJdW5pdCA9IEtCRF9USU1FT1VUX1NFQ09ORFM7Ci0JCWJyZWFrOwotCWNhc2UgJ20nOgotCQlpZiAodmFsdWUgPiBrYmRfaW5mby5taW51dGVzKQotCQkJY29udmVydCA9IHRydWU7Ci0JCXVuaXQgPSBLQkRfVElNRU9VVF9NSU5VVEVTOwotCQlicmVhazsKLQljYXNlICdoJzoKLQkJaWYgKHZhbHVlID4ga2JkX2luZm8uaG91cnMpCi0JCQljb252ZXJ0ID0gdHJ1ZTsKLQkJdW5pdCA9IEtCRF9USU1FT1VUX0hPVVJTOwotCQlicmVhazsKLQljYXNlICdkJzoKLQkJaWYgKHZhbHVlID4ga2JkX2luZm8uZGF5cykKLQkJCWNvbnZlcnQgPSB0cnVlOwotCQl1bml0ID0gS0JEX1RJTUVPVVRfREFZUzsKLQkJYnJlYWs7Ci0JZGVmYXVsdDoKLQkJcmV0dXJuIC1FSU5WQUw7Ci0JfQotCi0JaWYgKHF1aXJrcyAmJiBxdWlya3MtPm5lZWRzX2tiZF90aW1lb3V0cykKLQkJY29udmVydCA9IHRydWU7Ci0KLQlpZiAoY29udmVydCkgewotCQkvKiBDb252ZXJ0IHZhbHVlIGZyb20gY3VycmVudCB1bml0cyB0byBzZWNvbmRzICovCi0JCXN3aXRjaCAodW5pdCkgewotCQljYXNlIEtCRF9USU1FT1VUX0RBWVM6Ci0JCQl2YWx1ZSAqPSAyNDsKLQkJY2FzZSBLQkRfVElNRU9VVF9IT1VSUzoKLQkJCXZhbHVlICo9IDYwOwotCQljYXNlIEtCRF9USU1FT1VUX01JTlVURVM6Ci0JCQl2YWx1ZSAqPSA2MDsKLQkJCXVuaXQgPSBLQkRfVElNRU9VVF9TRUNPTkRTOwotCQl9Ci0KLQkJaWYgKHF1aXJrcyAmJiBxdWlya3MtPm5lZWRzX2tiZF90aW1lb3V0cykgewotCQkJZm9yIChpID0gMDsgcXVpcmtzLT5rYmRfdGltZW91dHNbaV0gIT0gLTE7IGkrKykgewotCQkJCWlmICh2YWx1ZSA8PSBxdWlya3MtPmtiZF90aW1lb3V0c1tpXSkgewotCQkJCQl2YWx1ZSA9IHF1aXJrcy0+a2JkX3RpbWVvdXRzW2ldOwotCQkJCQlicmVhazsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQotCQlpZiAodmFsdWUgPD0ga2JkX2luZm8uc2Vjb25kcyAmJiBrYmRfaW5mby5zZWNvbmRzKSB7Ci0JCQl1bml0ID0gS0JEX1RJTUVPVVRfU0VDT05EUzsKLQkJfSBlbHNlIGlmICh2YWx1ZSAvIDYwIDw9IGtiZF9pbmZvLm1pbnV0ZXMgJiYga2JkX2luZm8ubWludXRlcykgewotCQkJdmFsdWUgLz0gNjA7Ci0JCQl1bml0ID0gS0JEX1RJTUVPVVRfTUlOVVRFUzsKLQkJfSBlbHNlIGlmICh2YWx1ZSAvICg2MCAqIDYwKSA8PSBrYmRfaW5mby5ob3VycyAmJiBrYmRfaW5mby5ob3VycykgewotCQkJdmFsdWUgLz0gKDYwICogNjApOwotCQkJdW5pdCA9IEtCRF9USU1FT1VUX0hPVVJTOwotCQl9IGVsc2UgaWYgKHZhbHVlIC8gKDYwICogNjAgKiAyNCkgPD0ga2JkX2luZm8uZGF5cyAmJiBrYmRfaW5mby5kYXlzKSB7Ci0JCQl2YWx1ZSAvPSAoNjAgKiA2MCAqIDI0KTsKLQkJCXVuaXQgPSBLQkRfVElNRU9VVF9EQVlTOwotCQl9IGVsc2UgewotCQkJcmV0dXJuIC1FSU5WQUw7Ci0JCX0KLQl9Ci0KLQlyZXQgPSBrYmRfZ2V0X3N0YXRlKCZzdGF0ZSk7Ci0JaWYgKHJldCkKLQkJcmV0dXJuIHJldDsKLQotCW5ld19zdGF0ZSA9IHN0YXRlOwotCW5ld19zdGF0ZS50aW1lb3V0X3ZhbHVlID0gdmFsdWU7Ci0JbmV3X3N0YXRlLnRpbWVvdXRfdW5pdCA9IHVuaXQ7Ci0KLQlyZXQgPSBrYmRfc2V0X3N0YXRlX3NhZmUoJm5ld19zdGF0ZSwgJnN0YXRlKTsKLQlpZiAocmV0KQotCQlyZXR1cm4gcmV0OwotCi0JcmV0dXJuIGNvdW50OwotfQotCi1zdGF0aWMgc3NpemVfdCBrYmRfbGVkX3RpbWVvdXRfc2hvdyhzdHJ1Y3QgZGV2aWNlICpkZXYsCi0JCQkJICAgIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLCBjaGFyICpidWYpCi17Ci0Jc3RydWN0IGtiZF9zdGF0ZSBzdGF0ZTsKLQlpbnQgcmV0OwotCWludCBsZW47Ci0KLQlyZXQgPSBrYmRfZ2V0X3N0YXRlKCZzdGF0ZSk7Ci0JaWYgKHJldCkKLQkJcmV0dXJuIHJldDsKLQotCWxlbiA9IHNwcmludGYoYnVmLCAiJWQiLCBzdGF0ZS50aW1lb3V0X3ZhbHVlKTsKLQotCXN3aXRjaCAoc3RhdGUudGltZW91dF91bml0KSB7Ci0JY2FzZSBLQkRfVElNRU9VVF9TRUNPTkRTOgotCQlyZXR1cm4gbGVuICsgc3ByaW50ZihidWYrbGVuLCAic1xuIik7Ci0JY2FzZSBLQkRfVElNRU9VVF9NSU5VVEVTOgotCQlyZXR1cm4gbGVuICsgc3ByaW50ZihidWYrbGVuLCAibVxuIik7Ci0JY2FzZSBLQkRfVElNRU9VVF9IT1VSUzoKLQkJcmV0dXJuIGxlbiArIHNwcmludGYoYnVmK2xlbiwgImhcbiIpOwotCWNhc2UgS0JEX1RJTUVPVVRfREFZUzoKLQkJcmV0dXJuIGxlbiArIHNwcmludGYoYnVmK2xlbiwgImRcbiIpOwotCWRlZmF1bHQ6Ci0JCXJldHVybiAtRUlOVkFMOwotCX0KLQotCXJldHVybiBsZW47Ci19Ci0KLXN0YXRpYyBERVZJQ0VfQVRUUihzdG9wX3RpbWVvdXQsIFNfSVJVR08gfCBTX0lXVVNSLAotCQkgICBrYmRfbGVkX3RpbWVvdXRfc2hvdywga2JkX2xlZF90aW1lb3V0X3N0b3JlKTsKLQotc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBrYmRfbGVkX3RyaWdnZXJzW10gPSB7Ci0JImtleWJvYXJkIiwKLQkidG91Y2hwYWQiLAotCS8qInRyYWNrc3RpY2siKi8gTlVMTCwgLyogTk9URTogdHJhY2tzdGljayBpcyBqdXN0IGFsaWFzIGZvciB0b3VjaHBhZCAqLwotCSJtb3VzZSIsCi19OwotCi1zdGF0aWMgc3NpemVfdCBrYmRfbGVkX3RyaWdnZXJzX3N0b3JlKHN0cnVjdCBkZXZpY2UgKmRldiwKLQkJCQkgICAgICBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKLQkJCQkgICAgICBjb25zdCBjaGFyICpidWYsIHNpemVfdCBjb3VudCkKLXsKLQlzdHJ1Y3Qga2JkX3N0YXRlIG5ld19zdGF0ZTsKLQlzdHJ1Y3Qga2JkX3N0YXRlIHN0YXRlOwotCWJvb2wgdHJpZ2dlcnNfZW5hYmxlZCA9IGZhbHNlOwotCWJvb2wgYWxzX2VuYWJsZWQgPSBmYWxzZTsKLQlib29sIGRpc2FibGVfYWxzID0gZmFsc2U7Ci0JYm9vbCBlbmFibGVfYWxzID0gZmFsc2U7Ci0JaW50IHRyaWdnZXJfYml0ID0gLTE7Ci0JY2hhciB0cmlnZ2VyWzIxXTsKLQlpbnQgaSwgcmV0OwotCi0JcmV0ID0gc3NjYW5mKGJ1ZiwgIiUyMHMiLCB0cmlnZ2VyKTsKLQlpZiAocmV0ICE9IDEpCi0JCXJldHVybiAtRUlOVkFMOwotCi0JaWYgKHRyaWdnZXJbMF0gIT0gJysnICYmIHRyaWdnZXJbMF0gIT0gJy0nKQotCQlyZXR1cm4gLUVJTlZBTDsKLQotCXJldCA9IGtiZF9nZXRfc3RhdGUoJnN0YXRlKTsKLQlpZiAocmV0KQotCQlyZXR1cm4gcmV0OwotCi0JaWYgKGtiZF9hbHNfc3VwcG9ydGVkKQotCQlhbHNfZW5hYmxlZCA9IGtiZF9pc19hbHNfbW9kZV9iaXQoc3RhdGUubW9kZV9iaXQpOwotCi0JaWYgKGtiZF90cmlnZ2Vyc19zdXBwb3J0ZWQpCi0JCXRyaWdnZXJzX2VuYWJsZWQgPSBrYmRfaXNfdHJpZ2dlcl9tb2RlX2JpdChzdGF0ZS5tb2RlX2JpdCk7Ci0KLQlpZiAoa2JkX2Fsc19zdXBwb3J0ZWQpIHsKLQkJaWYgKHN0cmNtcCh0cmlnZ2VyLCAiK2FscyIpID09IDApIHsKLQkJCWlmIChhbHNfZW5hYmxlZCkKLQkJCQlyZXR1cm4gY291bnQ7Ci0JCQllbmFibGVfYWxzID0gdHJ1ZTsKLQkJfSBlbHNlIGlmIChzdHJjbXAodHJpZ2dlciwgIi1hbHMiKSA9PSAwKSB7Ci0JCQlpZiAoIWFsc19lbmFibGVkKQotCQkJCXJldHVybiBjb3VudDsKLQkJCWRpc2FibGVfYWxzID0gdHJ1ZTsKLQkJfQotCX0KLQotCWlmIChlbmFibGVfYWxzIHx8IGRpc2FibGVfYWxzKSB7Ci0JCW5ld19zdGF0ZSA9IHN0YXRlOwotCQlpZiAoZW5hYmxlX2FscykgewotCQkJaWYgKHRyaWdnZXJzX2VuYWJsZWQpCi0JCQkJbmV3X3N0YXRlLm1vZGVfYml0ID0gS0JEX01PREVfQklUX1RSSUdHRVJfQUxTOwotCQkJZWxzZQotCQkJCW5ld19zdGF0ZS5tb2RlX2JpdCA9IEtCRF9NT0RFX0JJVF9BTFM7Ci0JCX0gZWxzZSB7Ci0JCQlpZiAodHJpZ2dlcnNfZW5hYmxlZCkgewotCQkJCW5ld19zdGF0ZS5tb2RlX2JpdCA9IEtCRF9NT0RFX0JJVF9UUklHR0VSOwotCQkJCWtiZF9zZXRfbGV2ZWwoJm5ld19zdGF0ZSwga2JkX3ByZXZpb3VzX2xldmVsKTsKLQkJCX0gZWxzZSB7Ci0JCQkJbmV3X3N0YXRlLm1vZGVfYml0ID0gS0JEX01PREVfQklUX09OOwotCQkJfQotCQl9Ci0JCWlmICghKGtiZF9pbmZvLm1vZGVzICYgQklUKG5ld19zdGF0ZS5tb2RlX2JpdCkpKQotCQkJcmV0dXJuIC1FSU5WQUw7Ci0JCXJldCA9IGtiZF9zZXRfc3RhdGVfc2FmZSgmbmV3X3N0YXRlLCAmc3RhdGUpOwotCQlpZiAocmV0KQotCQkJcmV0dXJuIHJldDsKLQkJa2JkX3ByZXZpb3VzX21vZGVfYml0ID0gbmV3X3N0YXRlLm1vZGVfYml0OwotCQlyZXR1cm4gY291bnQ7Ci0JfQotCi0JaWYgKGtiZF90cmlnZ2Vyc19zdXBwb3J0ZWQpIHsKLQkJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUoa2JkX2xlZF90cmlnZ2Vycyk7ICsraSkgewotCQkJaWYgKCEoa2JkX2luZm8udHJpZ2dlcnMgJiBCSVQoaSkpKQotCQkJCWNvbnRpbnVlOwotCQkJaWYgKCFrYmRfbGVkX3RyaWdnZXJzW2ldKQotCQkJCWNvbnRpbnVlOwotCQkJaWYgKHN0cmNtcCh0cmlnZ2VyKzEsIGtiZF9sZWRfdHJpZ2dlcnNbaV0pICE9IDApCi0JCQkJY29udGludWU7Ci0JCQlpZiAodHJpZ2dlclswXSA9PSAnKycgJiYKLQkJCSAgICB0cmlnZ2Vyc19lbmFibGVkICYmIChzdGF0ZS50cmlnZ2VycyAmIEJJVChpKSkpCi0JCQkJcmV0dXJuIGNvdW50OwotCQkJaWYgKHRyaWdnZXJbMF0gPT0gJy0nICYmCi0JCQkgICAgKCF0cmlnZ2Vyc19lbmFibGVkIHx8ICEoc3RhdGUudHJpZ2dlcnMgJiBCSVQoaSkpKSkKLQkJCQlyZXR1cm4gY291bnQ7Ci0JCQl0cmlnZ2VyX2JpdCA9IGk7Ci0JCQlicmVhazsKLQkJfQotCX0KLQotCWlmICh0cmlnZ2VyX2JpdCAhPSAtMSkgewotCQluZXdfc3RhdGUgPSBzdGF0ZTsKLQkJaWYgKHRyaWdnZXJbMF0gPT0gJysnKQotCQkJbmV3X3N0YXRlLnRyaWdnZXJzIHw9IEJJVCh0cmlnZ2VyX2JpdCk7Ci0JCWVsc2UgewotCQkJbmV3X3N0YXRlLnRyaWdnZXJzICY9IH5CSVQodHJpZ2dlcl9iaXQpOwotCQkJLyogTk9URTogdHJhY2tzdGljayBiaXQgKDIpIG11c3QgYmUgZGlzYWJsZWQgd2hlbgotCQkJICogICAgICAgZGlzYWJsaW5nIHRvdWNocGFkIGJpdCAoMSksIG90aGVyd2lzZSB0b3VjaHBhZAotCQkJICogICAgICAgYml0ICgxKSB3aWxsIG5vdCBiZSBkaXNhYmxlZCAqLwotCQkJaWYgKHRyaWdnZXJfYml0ID09IDEpCi0JCQkJbmV3X3N0YXRlLnRyaWdnZXJzICY9IH5CSVQoMik7Ci0JCX0KLQkJaWYgKChrYmRfaW5mby50cmlnZ2VycyAmIG5ld19zdGF0ZS50cmlnZ2VycykgIT0KLQkJICAgIG5ld19zdGF0ZS50cmlnZ2VycykKLQkJCXJldHVybiAtRUlOVkFMOwotCQlpZiAobmV3X3N0YXRlLnRyaWdnZXJzICYmICF0cmlnZ2Vyc19lbmFibGVkKSB7Ci0JCQlpZiAoYWxzX2VuYWJsZWQpCi0JCQkJbmV3X3N0YXRlLm1vZGVfYml0ID0gS0JEX01PREVfQklUX1RSSUdHRVJfQUxTOwotCQkJZWxzZSB7Ci0JCQkJbmV3X3N0YXRlLm1vZGVfYml0ID0gS0JEX01PREVfQklUX1RSSUdHRVI7Ci0JCQkJa2JkX3NldF9sZXZlbCgmbmV3X3N0YXRlLCBrYmRfcHJldmlvdXNfbGV2ZWwpOwotCQkJfQotCQl9IGVsc2UgaWYgKG5ld19zdGF0ZS50cmlnZ2VycyA9PSAwKSB7Ci0JCQlpZiAoYWxzX2VuYWJsZWQpCi0JCQkJbmV3X3N0YXRlLm1vZGVfYml0ID0gS0JEX01PREVfQklUX0FMUzsKLQkJCWVsc2UKLQkJCQlrYmRfc2V0X2xldmVsKCZuZXdfc3RhdGUsIDApOwotCQl9Ci0JCWlmICghKGtiZF9pbmZvLm1vZGVzICYgQklUKG5ld19zdGF0ZS5tb2RlX2JpdCkpKQotCQkJcmV0dXJuIC1FSU5WQUw7Ci0JCXJldCA9IGtiZF9zZXRfc3RhdGVfc2FmZSgmbmV3X3N0YXRlLCAmc3RhdGUpOwotCQlpZiAocmV0KQotCQkJcmV0dXJuIHJldDsKLQkJaWYgKG5ld19zdGF0ZS5tb2RlX2JpdCAhPSBLQkRfTU9ERV9CSVRfT0ZGKQotCQkJa2JkX3ByZXZpb3VzX21vZGVfYml0ID0gbmV3X3N0YXRlLm1vZGVfYml0OwotCQlyZXR1cm4gY291bnQ7Ci0JfQotCi0JcmV0dXJuIC1FSU5WQUw7Ci19Ci0KLXN0YXRpYyBzc2l6ZV90IGtiZF9sZWRfdHJpZ2dlcnNfc2hvdyhzdHJ1Y3QgZGV2aWNlICpkZXYsCi0JCQkJICAgICBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwgY2hhciAqYnVmKQotewotCXN0cnVjdCBrYmRfc3RhdGUgc3RhdGU7Ci0JYm9vbCB0cmlnZ2Vyc19lbmFibGVkOwotCWludCBsZXZlbCwgaSwgcmV0OwotCWludCBsZW4gPSAwOwotCi0JcmV0ID0ga2JkX2dldF9zdGF0ZSgmc3RhdGUpOwotCWlmIChyZXQpCi0JCXJldHVybiByZXQ7Ci0KLQlsZW4gPSAwOwotCi0JaWYgKGtiZF90cmlnZ2Vyc19zdXBwb3J0ZWQpIHsKLQkJdHJpZ2dlcnNfZW5hYmxlZCA9IGtiZF9pc190cmlnZ2VyX21vZGVfYml0KHN0YXRlLm1vZGVfYml0KTsKLQkJbGV2ZWwgPSBrYmRfZ2V0X2xldmVsKCZzdGF0ZSk7Ci0JCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKGtiZF9sZWRfdHJpZ2dlcnMpOyArK2kpIHsKLQkJCWlmICghKGtiZF9pbmZvLnRyaWdnZXJzICYgQklUKGkpKSkKLQkJCQljb250aW51ZTsKLQkJCWlmICgha2JkX2xlZF90cmlnZ2Vyc1tpXSkKLQkJCQljb250aW51ZTsKLQkJCWlmICgodHJpZ2dlcnNfZW5hYmxlZCB8fCBsZXZlbCA8PSAwKSAmJgotCQkJICAgIChzdGF0ZS50cmlnZ2VycyAmIEJJVChpKSkpCi0JCQkJYnVmW2xlbisrXSA9ICcrJzsKLQkJCWVsc2UKLQkJCQlidWZbbGVuKytdID0gJy0nOwotCQkJbGVuICs9IHNwcmludGYoYnVmK2xlbiwgIiVzICIsIGtiZF9sZWRfdHJpZ2dlcnNbaV0pOwotCQl9Ci0JfQotCi0JaWYgKGtiZF9hbHNfc3VwcG9ydGVkKSB7Ci0JCWlmIChrYmRfaXNfYWxzX21vZGVfYml0KHN0YXRlLm1vZGVfYml0KSkKLQkJCWxlbiArPSBzcHJpbnRmKGJ1ZitsZW4sICIrYWxzICIpOwotCQllbHNlCi0JCQlsZW4gKz0gc3ByaW50ZihidWYrbGVuLCAiLWFscyAiKTsKLQl9Ci0KLQlpZiAobGVuKQotCQlidWZbbGVuIC0gMV0gPSAnXG4nOwotCi0JcmV0dXJuIGxlbjsKLX0KLQotc3RhdGljIERFVklDRV9BVFRSKHN0YXJ0X3RyaWdnZXJzLCBTX0lSVUdPIHwgU19JV1VTUiwKLQkJICAga2JkX2xlZF90cmlnZ2Vyc19zaG93LCBrYmRfbGVkX3RyaWdnZXJzX3N0b3JlKTsKLQotc3RhdGljIHNzaXplX3Qga2JkX2xlZF9hbHNfc3RvcmUoc3RydWN0IGRldmljZSAqZGV2LAotCQkJCSBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKLQkJCQkgY29uc3QgY2hhciAqYnVmLCBzaXplX3QgY291bnQpCi17Ci0Jc3RydWN0IGtiZF9zdGF0ZSBzdGF0ZTsKLQlzdHJ1Y3Qga2JkX3N0YXRlIG5ld19zdGF0ZTsKLQl1OCBzZXR0aW5nOwotCWludCByZXQ7Ci0KLQlyZXQgPSBrc3RydG91OChidWYsIDEwLCAmc2V0dGluZyk7Ci0JaWYgKHJldCkKLQkJcmV0dXJuIHJldDsKLQotCXJldCA9IGtiZF9nZXRfc3RhdGUoJnN0YXRlKTsKLQlpZiAocmV0KQotCQlyZXR1cm4gcmV0OwotCi0JbmV3X3N0YXRlID0gc3RhdGU7Ci0JbmV3X3N0YXRlLmFsc19zZXR0aW5nID0gc2V0dGluZzsKLQotCXJldCA9IGtiZF9zZXRfc3RhdGVfc2FmZSgmbmV3X3N0YXRlLCAmc3RhdGUpOwotCWlmIChyZXQpCi0JCXJldHVybiByZXQ7Ci0KLQlyZXR1cm4gY291bnQ7Ci19Ci0KLXN0YXRpYyBzc2l6ZV90IGtiZF9sZWRfYWxzX3Nob3coc3RydWN0IGRldmljZSAqZGV2LAotCQkJCXN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLCBjaGFyICpidWYpCi17Ci0Jc3RydWN0IGtiZF9zdGF0ZSBzdGF0ZTsKLQlpbnQgcmV0OwotCi0JcmV0ID0ga2JkX2dldF9zdGF0ZSgmc3RhdGUpOwotCWlmIChyZXQpCi0JCXJldHVybiByZXQ7Ci0KLQlyZXR1cm4gc3ByaW50ZihidWYsICIlZFxuIiwgc3RhdGUuYWxzX3NldHRpbmcpOwotfQotCi1zdGF0aWMgREVWSUNFX0FUVFIoYWxzX3NldHRpbmcsIFNfSVJVR08gfCBTX0lXVVNSLAotCQkgICBrYmRfbGVkX2Fsc19zaG93LCBrYmRfbGVkX2Fsc19zdG9yZSk7Ci0KLXN0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICprYmRfbGVkX2F0dHJzW10gPSB7Ci0JJmRldl9hdHRyX3N0b3BfdGltZW91dC5hdHRyLAotCSZkZXZfYXR0cl9zdGFydF90cmlnZ2Vycy5hdHRyLAotCSZkZXZfYXR0cl9hbHNfc2V0dGluZy5hdHRyLAotCU5VTEwsCi19OwotQVRUUklCVVRFX0dST1VQUyhrYmRfbGVkKTsKLQotc3RhdGljIGVudW0gbGVkX2JyaWdodG5lc3Mga2JkX2xlZF9sZXZlbF9nZXQoc3RydWN0IGxlZF9jbGFzc2RldiAqbGVkX2NkZXYpCi17Ci0JaW50IHJldDsKLQl1MTYgbnVtOwotCXN0cnVjdCBrYmRfc3RhdGUgc3RhdGU7Ci0KLQlpZiAoa2JkX2dldF9tYXhfbGV2ZWwoKSkgewotCQlyZXQgPSBrYmRfZ2V0X3N0YXRlKCZzdGF0ZSk7Ci0JCWlmIChyZXQpCi0JCQlyZXR1cm4gMDsKLQkJcmV0ID0ga2JkX2dldF9sZXZlbCgmc3RhdGUpOwotCQlpZiAocmV0IDwgMCkKLQkJCXJldHVybiAwOwotCQlyZXR1cm4gcmV0OwotCX0KLQotCWlmIChrYmRfZ2V0X3ZhbGlkX3Rva2VuX2NvdW50cygpKSB7Ci0JCXJldCA9IGtiZF9nZXRfZmlyc3RfYWN0aXZlX3Rva2VuX2JpdCgpOwotCQlpZiAocmV0IDwgMCkKLQkJCXJldHVybiAwOwotCQlmb3IgKG51bSA9IGtiZF90b2tlbl9iaXRzOyBudW0gIT0gMCAmJiByZXQgPiAwOyAtLXJldCkKLQkJCW51bSAmPSBudW0gLSAxOyAvKiBjbGVhciB0aGUgZmlyc3QgYml0IHNldCAqLwotCQlpZiAobnVtID09IDApCi0JCQlyZXR1cm4gMDsKLQkJcmV0dXJuIGZmcyhudW0pIC0gMTsKLQl9Ci0KLQlwcl93YXJuKCJLZXlib2FyZCBicmlnaHRuZXNzIGxldmVsIGNvbnRyb2wgbm90IHN1cHBvcnRlZFxuIik7Ci0JcmV0dXJuIDA7Ci19Ci0KLXN0YXRpYyB2b2lkIGtiZF9sZWRfbGV2ZWxfc2V0KHN0cnVjdCBsZWRfY2xhc3NkZXYgKmxlZF9jZGV2LAotCQkJICAgICAgZW51bSBsZWRfYnJpZ2h0bmVzcyB2YWx1ZSkKLXsKLQlzdHJ1Y3Qga2JkX3N0YXRlIHN0YXRlOwotCXN0cnVjdCBrYmRfc3RhdGUgbmV3X3N0YXRlOwotCXUxNiBudW07Ci0KLQlpZiAoa2JkX2dldF9tYXhfbGV2ZWwoKSkgewotCQlpZiAoa2JkX2dldF9zdGF0ZSgmc3RhdGUpKQotCQkJcmV0dXJuOwotCQluZXdfc3RhdGUgPSBzdGF0ZTsKLQkJaWYgKGtiZF9zZXRfbGV2ZWwoJm5ld19zdGF0ZSwgdmFsdWUpKQotCQkJcmV0dXJuOwotCQlrYmRfc2V0X3N0YXRlX3NhZmUoJm5ld19zdGF0ZSwgJnN0YXRlKTsKLQkJcmV0dXJuOwotCX0KLQotCWlmIChrYmRfZ2V0X3ZhbGlkX3Rva2VuX2NvdW50cygpKSB7Ci0JCWZvciAobnVtID0ga2JkX3Rva2VuX2JpdHM7IG51bSAhPSAwICYmIHZhbHVlID4gMDsgLS12YWx1ZSkKLQkJCW51bSAmPSBudW0gLSAxOyAvKiBjbGVhciB0aGUgZmlyc3QgYml0IHNldCAqLwotCQlpZiAobnVtID09IDApCi0JCQlyZXR1cm47Ci0JCWtiZF9zZXRfdG9rZW5fYml0KGZmcyhudW0pIC0gMSk7Ci0JCXJldHVybjsKLQl9Ci0KLQlwcl93YXJuKCJLZXlib2FyZCBicmlnaHRuZXNzIGxldmVsIGNvbnRyb2wgbm90IHN1cHBvcnRlZFxuIik7Ci19Ci0KLXN0YXRpYyBzdHJ1Y3QgbGVkX2NsYXNzZGV2IGtiZF9sZWQgPSB7Ci0JLm5hbWUgICAgICAgICAgID0gImRlbGw6OmtiZF9iYWNrbGlnaHQiLAotCS5icmlnaHRuZXNzX3NldCA9IGtiZF9sZWRfbGV2ZWxfc2V0LAotCS5icmlnaHRuZXNzX2dldCA9IGtiZF9sZWRfbGV2ZWxfZ2V0LAotCS5ncm91cHMgICAgICAgICA9IGtiZF9sZWRfZ3JvdXBzLAotfTsKLQotc3RhdGljIGludCBfX2luaXQga2JkX2xlZF9pbml0KHN0cnVjdCBkZXZpY2UgKmRldikKLXsKLQlrYmRfaW5pdCgpOwotCWlmICgha2JkX2xlZF9wcmVzZW50KQotCQlyZXR1cm4gLUVOT0RFVjsKLQlrYmRfbGVkLm1heF9icmlnaHRuZXNzID0ga2JkX2dldF9tYXhfbGV2ZWwoKTsKLQlpZiAoIWtiZF9sZWQubWF4X2JyaWdodG5lc3MpIHsKLQkJa2JkX2xlZC5tYXhfYnJpZ2h0bmVzcyA9IGtiZF9nZXRfdmFsaWRfdG9rZW5fY291bnRzKCk7Ci0JCWlmIChrYmRfbGVkLm1heF9icmlnaHRuZXNzKQotCQkJa2JkX2xlZC5tYXhfYnJpZ2h0bmVzcy0tOwotCX0KLQlyZXR1cm4gbGVkX2NsYXNzZGV2X3JlZ2lzdGVyKGRldiwgJmtiZF9sZWQpOwotfQotCi1zdGF0aWMgdm9pZCBicmlnaHRuZXNzX3NldF9leGl0KHN0cnVjdCBsZWRfY2xhc3NkZXYgKmxlZF9jZGV2LAotCQkJCWVudW0gbGVkX2JyaWdodG5lc3MgdmFsdWUpCi17Ci0JLyogRG9uJ3QgY2hhbmdlIGJhY2tsaWdodCBsZXZlbCBvbiBleGl0ICovCi19OwotCi1zdGF0aWMgdm9pZCBrYmRfbGVkX2V4aXQodm9pZCkKLXsKLQlpZiAoIWtiZF9sZWRfcHJlc2VudCkKLQkJcmV0dXJuOwotCWtiZF9sZWQuYnJpZ2h0bmVzc19zZXQgPSBicmlnaHRuZXNzX3NldF9leGl0OwotCWxlZF9jbGFzc2Rldl91bnJlZ2lzdGVyKCZrYmRfbGVkKTsKLX0KLQogc3RhdGljIGludCBfX2luaXQgZGVsbF9pbml0KHZvaWQpCiB7CiAJaW50IG1heF9pbnRlbnNpdHkgPSAwOwpAQCAtMTg3OSw4ICs4NDEsNiBAQAogCWlmIChxdWlya3MgJiYgcXVpcmtzLT50b3VjaHBhZF9sZWQpCiAJCXRvdWNocGFkX2xlZF9pbml0KCZwbGF0Zm9ybV9kZXZpY2UtPmRldik7CiAKLQlrYmRfbGVkX2luaXQoJnBsYXRmb3JtX2RldmljZS0+ZGV2KTsKLQogCWRlbGxfbGFwdG9wX2RpciA9IGRlYnVnZnNfY3JlYXRlX2RpcigiZGVsbF9sYXB0b3AiLCBOVUxMKTsKIAlpZiAoZGVsbF9sYXB0b3BfZGlyICE9IE5VTEwpCiAJCWRlYnVnZnNfY3JlYXRlX2ZpbGUoInJma2lsbCIsIDA0NDQsIGRlbGxfbGFwdG9wX2RpciwgTlVMTCwKQEAgLTE5NDgsNyArOTA4LDYgQEAKIAlkZWJ1Z2ZzX3JlbW92ZV9yZWN1cnNpdmUoZGVsbF9sYXB0b3BfZGlyKTsKIAlpZiAocXVpcmtzICYmIHF1aXJrcy0+dG91Y2hwYWRfbGVkKQogCQl0b3VjaHBhZF9sZWRfZXhpdCgpOwotCWtiZF9sZWRfZXhpdCgpOwogCWk4MDQyX3JlbW92ZV9maWx0ZXIoZGVsbF9sYXB0b3BfaTgwNDJfZmlsdGVyKTsKIAljYW5jZWxfZGVsYXllZF93b3JrX3N5bmMoJmRlbGxfcmZraWxsX3dvcmspOwogCWJhY2tsaWdodF9kZXZpY2VfdW5yZWdpc3RlcihkZWxsX2JhY2tsaWdodF9kZXZpY2UpOwpAQCAtMTk2NSw3ICs5MjQsNSBAQAogbW9kdWxlX2V4aXQoZGVsbF9leGl0KTsKIAogTU9EVUxFX0FVVEhPUigiTWF0dGhldyBHYXJyZXR0IDxtamdAcmVkaGF0LmNvbT4iKTsKLU1PRFVMRV9BVVRIT1IoIkdhYnJpZWxlIE1henpvdHRhIDxnYWJyaWVsZS5tenRAZ21haWwuY29tPiIpOwotTU9EVUxFX0FVVEhPUigiUGFsaSBSb2jDoXIgPHBhbGkucm9oYXJAZ21haWwuY29tPiIpOwogTU9EVUxFX0RFU0NSSVBUSU9OKCJEZWxsIGxhcHRvcCBkcml2ZXIiKTsKIE1PRFVMRV9MSUNFTlNFKCJHUEwiKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcG5wL3BucGFjcGkvcnNwYXJzZXIuYyBiL2RyaXZlcnMvcG5wL3BucGFjcGkvcnNwYXJzZXIuYwppbmRleCA2Njk3N2ViLi5mZjAzNTZmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BucC9wbnBhY3BpL3JzcGFyc2VyLmMKKysrIGIvZHJpdmVycy9wbnAvcG5wYWNwaS9yc3BhcnNlci5jCkBAIC0xODAsMjAgKzE4MCwyMSBAQAogCXN0cnVjdCBwbnBfZGV2ICpkZXYgPSBkYXRhOwogCXN0cnVjdCBhY3BpX3Jlc291cmNlX2RtYSAqZG1hOwogCXN0cnVjdCBhY3BpX3Jlc291cmNlX3ZlbmRvcl90eXBlZCAqdmVuZG9yX3R5cGVkOwotCXN0cnVjdCByZXNvdXJjZSByID0gezB9OworCXN0cnVjdCByZXNvdXJjZV93aW4gd2luID0ge3swfSwgMH07CisJc3RydWN0IHJlc291cmNlICpyID0gJndpbi5yZXM7CiAJaW50IGksIGZsYWdzOwogCi0JaWYgKGFjcGlfZGV2X3Jlc291cmNlX2FkZHJlc3Nfc3BhY2UocmVzLCAmcikKLQkgICAgfHwgYWNwaV9kZXZfcmVzb3VyY2VfZXh0X2FkZHJlc3Nfc3BhY2UocmVzLCAmcikpIHsKLQkJcG5wX2FkZF9yZXNvdXJjZShkZXYsICZyKTsKKwlpZiAoYWNwaV9kZXZfcmVzb3VyY2VfYWRkcmVzc19zcGFjZShyZXMsICZ3aW4pCisJICAgIHx8IGFjcGlfZGV2X3Jlc291cmNlX2V4dF9hZGRyZXNzX3NwYWNlKHJlcywgJndpbikpIHsKKwkJcG5wX2FkZF9yZXNvdXJjZShkZXYsICZ3aW4ucmVzKTsKIAkJcmV0dXJuIEFFX09LOwogCX0KIAotCXIuZmxhZ3MgPSAwOwotCWlmIChhY3BpX2Rldl9yZXNvdXJjZV9pbnRlcnJ1cHQocmVzLCAwLCAmcikpIHsKLQkJcG5wYWNwaV9hZGRfaXJxcmVzb3VyY2UoZGV2LCAmcik7Ci0JCWZvciAoaSA9IDE7IGFjcGlfZGV2X3Jlc291cmNlX2ludGVycnVwdChyZXMsIGksICZyKTsgaSsrKQotCQkJcG5wYWNwaV9hZGRfaXJxcmVzb3VyY2UoZGV2LCAmcik7CisJci0+ZmxhZ3MgPSAwOworCWlmIChhY3BpX2Rldl9yZXNvdXJjZV9pbnRlcnJ1cHQocmVzLCAwLCByKSkgeworCQlwbnBhY3BpX2FkZF9pcnFyZXNvdXJjZShkZXYsIHIpOworCQlmb3IgKGkgPSAxOyBhY3BpX2Rldl9yZXNvdXJjZV9pbnRlcnJ1cHQocmVzLCBpLCByKTsgaSsrKQorCQkJcG5wYWNwaV9hZGRfaXJxcmVzb3VyY2UoZGV2LCByKTsKIAogCQlpZiAoaSA+IDEpIHsKIAkJCS8qCkBAIC0yMDksNyArMjEwLDcgQEAKIAkJCX0KIAkJfQogCQlyZXR1cm4gQUVfT0s7Ci0JfSBlbHNlIGlmIChyLmZsYWdzICYgSU9SRVNPVVJDRV9ESVNBQkxFRCkgeworCX0gZWxzZSBpZiAoci0+ZmxhZ3MgJiBJT1JFU09VUkNFX0RJU0FCTEVEKSB7CiAJCXBucF9hZGRfaXJxX3Jlc291cmNlKGRldiwgMCwgSU9SRVNPVVJDRV9ESVNBQkxFRCk7CiAJCXJldHVybiBBRV9PSzsKIAl9CkBAIC0yMTgsMTMgKzIxOSwxMyBAQAogCWNhc2UgQUNQSV9SRVNPVVJDRV9UWVBFX01FTU9SWTI0OgogCWNhc2UgQUNQSV9SRVNPVVJDRV9UWVBFX01FTU9SWTMyOgogCWNhc2UgQUNQSV9SRVNPVVJDRV9UWVBFX0ZJWEVEX01FTU9SWTMyOgotCQlpZiAoYWNwaV9kZXZfcmVzb3VyY2VfbWVtb3J5KHJlcywgJnIpKQotCQkJcG5wX2FkZF9yZXNvdXJjZShkZXYsICZyKTsKKwkJaWYgKGFjcGlfZGV2X3Jlc291cmNlX21lbW9yeShyZXMsIHIpKQorCQkJcG5wX2FkZF9yZXNvdXJjZShkZXYsIHIpOwogCQlicmVhazsKIAljYXNlIEFDUElfUkVTT1VSQ0VfVFlQRV9JTzoKIAljYXNlIEFDUElfUkVTT1VSQ0VfVFlQRV9GSVhFRF9JTzoKLQkJaWYgKGFjcGlfZGV2X3Jlc291cmNlX2lvKHJlcywgJnIpKQotCQkJcG5wX2FkZF9yZXNvdXJjZShkZXYsICZyKTsKKwkJaWYgKGFjcGlfZGV2X3Jlc291cmNlX2lvKHJlcywgcikpCisJCQlwbnBfYWRkX3Jlc291cmNlKGRldiwgcik7CiAJCWJyZWFrOwogCWNhc2UgQUNQSV9SRVNPVVJDRV9UWVBFX0RNQToKIAkJZG1hID0gJnJlcy0+ZGF0YS5kbWE7CkBAIC00MTAsMTIgKzQxMSwxMiBAQAogCWlmIChwLT5yZXNvdXJjZV90eXBlID09IEFDUElfTUVNT1JZX1JBTkdFKSB7CiAJCWlmIChwLT5pbmZvLm1lbS53cml0ZV9wcm90ZWN0ID09IEFDUElfUkVBRF9XUklURV9NRU1PUlkpCiAJCQlmbGFncyA9IElPUkVTT1VSQ0VfTUVNX1dSSVRFQUJMRTsKLQkJcG5wX3JlZ2lzdGVyX21lbV9yZXNvdXJjZShkZXYsIG9wdGlvbl9mbGFncywgcC0+bWluaW11bSwKLQkJCQkJICBwLT5taW5pbXVtLCAwLCBwLT5hZGRyZXNzX2xlbmd0aCwKKwkJcG5wX3JlZ2lzdGVyX21lbV9yZXNvdXJjZShkZXYsIG9wdGlvbl9mbGFncywgcC0+YWRkcmVzcy5taW5pbXVtLAorCQkJCQkgIHAtPmFkZHJlc3MubWluaW11bSwgMCwgcC0+YWRkcmVzcy5hZGRyZXNzX2xlbmd0aCwKIAkJCQkJICBmbGFncyk7CiAJfSBlbHNlIGlmIChwLT5yZXNvdXJjZV90eXBlID09IEFDUElfSU9fUkFOR0UpCi0JCXBucF9yZWdpc3Rlcl9wb3J0X3Jlc291cmNlKGRldiwgb3B0aW9uX2ZsYWdzLCBwLT5taW5pbXVtLAotCQkJCQkgICBwLT5taW5pbXVtLCAwLCBwLT5hZGRyZXNzX2xlbmd0aCwKKwkJcG5wX3JlZ2lzdGVyX3BvcnRfcmVzb3VyY2UoZGV2LCBvcHRpb25fZmxhZ3MsIHAtPmFkZHJlc3MubWluaW11bSwKKwkJCQkJICAgcC0+YWRkcmVzcy5taW5pbXVtLCAwLCBwLT5hZGRyZXNzLmFkZHJlc3NfbGVuZ3RoLAogCQkJCQkgICBJT1JFU09VUkNFX0lPX0ZJWEVEKTsKIH0KIApAQCAtNDI5LDEyICs0MzAsMTIgQEAKIAlpZiAocC0+cmVzb3VyY2VfdHlwZSA9PSBBQ1BJX01FTU9SWV9SQU5HRSkgewogCQlpZiAocC0+aW5mby5tZW0ud3JpdGVfcHJvdGVjdCA9PSBBQ1BJX1JFQURfV1JJVEVfTUVNT1JZKQogCQkJZmxhZ3MgPSBJT1JFU09VUkNFX01FTV9XUklURUFCTEU7Ci0JCXBucF9yZWdpc3Rlcl9tZW1fcmVzb3VyY2UoZGV2LCBvcHRpb25fZmxhZ3MsIHAtPm1pbmltdW0sCi0JCQkJCSAgcC0+bWluaW11bSwgMCwgcC0+YWRkcmVzc19sZW5ndGgsCisJCXBucF9yZWdpc3Rlcl9tZW1fcmVzb3VyY2UoZGV2LCBvcHRpb25fZmxhZ3MsIHAtPmFkZHJlc3MubWluaW11bSwKKwkJCQkJICBwLT5hZGRyZXNzLm1pbmltdW0sIDAsIHAtPmFkZHJlc3MuYWRkcmVzc19sZW5ndGgsCiAJCQkJCSAgZmxhZ3MpOwogCX0gZWxzZSBpZiAocC0+cmVzb3VyY2VfdHlwZSA9PSBBQ1BJX0lPX1JBTkdFKQotCQlwbnBfcmVnaXN0ZXJfcG9ydF9yZXNvdXJjZShkZXYsIG9wdGlvbl9mbGFncywgcC0+bWluaW11bSwKLQkJCQkJICAgcC0+bWluaW11bSwgMCwgcC0+YWRkcmVzc19sZW5ndGgsCisJCXBucF9yZWdpc3Rlcl9wb3J0X3Jlc291cmNlKGRldiwgb3B0aW9uX2ZsYWdzLCBwLT5hZGRyZXNzLm1pbmltdW0sCisJCQkJCSAgIHAtPmFkZHJlc3MubWluaW11bSwgMCwgcC0+YWRkcmVzcy5hZGRyZXNzX2xlbmd0aCwKIAkJCQkJICAgSU9SRVNPVVJDRV9JT19GSVhFRCk7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcmVndWxhdG9yL2NvcmUuYyBiL2RyaXZlcnMvcmVndWxhdG9yL2NvcmUuYwppbmRleCBlMjI1NzExLi45YzQ4ZmIzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3JlZ3VsYXRvci9jb3JlLmMKKysrIGIvZHJpdmVycy9yZWd1bGF0b3IvY29yZS5jCkBAIC0xNDg4LDcgKzE0ODgsNyBAQAogfQogRVhQT1JUX1NZTUJPTF9HUEwocmVndWxhdG9yX2dldF9vcHRpb25hbCk7CiAKLS8qIExvY2tzIGhlbGQgYnkgcmVndWxhdG9yX3B1dCgpICovCisvKiByZWd1bGF0b3JfbGlzdF9tdXRleCBsb2NrIGhlbGQgYnkgcmVndWxhdG9yX3B1dCgpICovCiBzdGF0aWMgdm9pZCBfcmVndWxhdG9yX3B1dChzdHJ1Y3QgcmVndWxhdG9yICpyZWd1bGF0b3IpCiB7CiAJc3RydWN0IHJlZ3VsYXRvcl9kZXYgKnJkZXY7CkBAIC0xNTAzLDEyICsxNTAzLDE0IEBACiAJLyogcmVtb3ZlIGFueSBzeXNmcyBlbnRyaWVzICovCiAJaWYgKHJlZ3VsYXRvci0+ZGV2KQogCQlzeXNmc19yZW1vdmVfbGluaygmcmRldi0+ZGV2LmtvYmosIHJlZ3VsYXRvci0+c3VwcGx5X25hbWUpOworCW11dGV4X2xvY2soJnJkZXYtPm11dGV4KTsKIAlrZnJlZShyZWd1bGF0b3ItPnN1cHBseV9uYW1lKTsKIAlsaXN0X2RlbCgmcmVndWxhdG9yLT5saXN0KTsKIAlrZnJlZShyZWd1bGF0b3IpOwogCiAJcmRldi0+b3Blbl9jb3VudC0tOwogCXJkZXYtPmV4Y2x1c2l2ZSA9IDA7CisJbXV0ZXhfdW5sb2NrKCZyZGV2LT5tdXRleCk7CiAKIAltb2R1bGVfcHV0KHJkZXYtPm93bmVyKTsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvcmVndWxhdG9yL3MybXBzMTEuYyBiL2RyaXZlcnMvcmVndWxhdG9yL3MybXBzMTEuYwppbmRleCAyODA5YWUwLi5mZjgyODExIDEwMDY0NAotLS0gYS9kcml2ZXJzL3JlZ3VsYXRvci9zMm1wczExLmMKKysrIGIvZHJpdmVycy9yZWd1bGF0b3IvczJtcHMxMS5jCkBAIC00MDUsNiArNDA1LDQwIEBACiAJLmVuYWJsZV9tYXNrCT0gUzJNUFMxNF9FTkFCTEVfTUFTSwkJCVwKIH0KIAorI2RlZmluZSByZWd1bGF0b3JfZGVzY19zMm1wczEzX2J1Y2s3KG51bSwgbWluLCBzdGVwLCBtaW5fc2VsKSB7CVwKKwkubmFtZQkJPSAiQlVDSyIjbnVtLAkJCQlcCisJLmlkCQk9IFMyTVBTMTNfQlVDSyMjbnVtLAkJCVwKKwkub3BzCQk9ICZzMm1wczE0X3JlZ19vcHMsCQkJXAorCS50eXBlCQk9IFJFR1VMQVRPUl9WT0xUQUdFLAkJCVwKKwkub3duZXIJCT0gVEhJU19NT0RVTEUsCQkJCVwKKwkubWluX3VWCQk9IG1pbiwJCQkJCVwKKwkudVZfc3RlcAk9IHN0ZXAsCQkJCQlcCisJLmxpbmVhcl9taW5fc2VsCT0gbWluX3NlbCwJCQkJXAorCS5uX3ZvbHRhZ2VzCT0gUzJNUFMxNF9CVUNLX05fVk9MVEFHRVMsCQlcCisJLnJhbXBfZGVsYXkJPSBTMk1QUzEzX0JVQ0tfUkFNUF9ERUxBWSwJCVwKKwkudnNlbF9yZWcJPSBTMk1QUzEzX1JFR19CMU9VVCArIChudW0pICogMiAtIDEsCVwKKwkudnNlbF9tYXNrCT0gUzJNUFMxNF9CVUNLX1ZTRUxfTUFTSywJCVwKKwkuZW5hYmxlX3JlZwk9IFMyTVBTMTNfUkVHX0IxQ1RSTCArIChudW0gLSAxKSAqIDIsCVwKKwkuZW5hYmxlX21hc2sJPSBTMk1QUzE0X0VOQUJMRV9NQVNLCQkJXAorfQorCisjZGVmaW5lIHJlZ3VsYXRvcl9kZXNjX3MybXBzMTNfYnVjazhfMTAobnVtLCBtaW4sIHN0ZXAsIG1pbl9zZWwpIHsJXAorCS5uYW1lCQk9ICJCVUNLIiNudW0sCQkJCVwKKwkuaWQJCT0gUzJNUFMxM19CVUNLIyNudW0sCQkJXAorCS5vcHMJCT0gJnMybXBzMTRfcmVnX29wcywJCQlcCisJLnR5cGUJCT0gUkVHVUxBVE9SX1ZPTFRBR0UsCQkJXAorCS5vd25lcgkJPSBUSElTX01PRFVMRSwJCQkJXAorCS5taW5fdVYJCT0gbWluLAkJCQkJXAorCS51Vl9zdGVwCT0gc3RlcCwJCQkJCVwKKwkubGluZWFyX21pbl9zZWwJPSBtaW5fc2VsLAkJCQlcCisJLm5fdm9sdGFnZXMJPSBTMk1QUzE0X0JVQ0tfTl9WT0xUQUdFUywJCVwKKwkucmFtcF9kZWxheQk9IFMyTVBTMTNfQlVDS19SQU1QX0RFTEFZLAkJXAorCS52c2VsX3JlZwk9IFMyTVBTMTNfUkVHX0IxT1VUICsgKG51bSkgKiAyIC0gMSwJXAorCS52c2VsX21hc2sJPSBTMk1QUzE0X0JVQ0tfVlNFTF9NQVNLLAkJXAorCS5lbmFibGVfcmVnCT0gUzJNUFMxM19SRUdfQjFDVFJMICsgKG51bSkgKiAyIC0gMSwJXAorCS5lbmFibGVfbWFzawk9IFMyTVBTMTRfRU5BQkxFX01BU0sJCQlcCit9CisKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgcmVndWxhdG9yX2Rlc2MgczJtcHMxM19yZWd1bGF0b3JzW10gPSB7CiAJcmVndWxhdG9yX2Rlc2NfczJtcHMxM19sZG8oMSwgIE1JTl84MDBfTVYsICBTVEVQXzEyXzVfTVYsIDB4MDApLAogCXJlZ3VsYXRvcl9kZXNjX3MybXBzMTNfbGRvKDIsICBNSU5fMTQwMF9NViwgU1RFUF81MF9NViwgICAweDBDKSwKQEAgLTQ1MiwxMCArNDg2LDEwIEBACiAJcmVndWxhdG9yX2Rlc2NfczJtcHMxM19idWNrKDQsICBNSU5fNTAwX01WLCAgU1RFUF82XzI1X01WLCAweDEwKSwKIAlyZWd1bGF0b3JfZGVzY19zMm1wczEzX2J1Y2soNSwgIE1JTl81MDBfTVYsICBTVEVQXzZfMjVfTVYsIDB4MTApLAogCXJlZ3VsYXRvcl9kZXNjX3MybXBzMTNfYnVjayg2LCAgTUlOXzUwMF9NViwgIFNURVBfNl8yNV9NViwgMHgxMCksCi0JcmVndWxhdG9yX2Rlc2NfczJtcHMxM19idWNrKDcsICBNSU5fNTAwX01WLCAgU1RFUF82XzI1X01WLCAweDEwKSwKLQlyZWd1bGF0b3JfZGVzY19zMm1wczEzX2J1Y2soOCwgIE1JTl8xMDAwX01WLCBTVEVQXzEyXzVfTVYsIDB4MjApLAotCXJlZ3VsYXRvcl9kZXNjX3MybXBzMTNfYnVjayg5LCAgTUlOXzEwMDBfTVYsIFNURVBfMTJfNV9NViwgMHgyMCksCi0JcmVndWxhdG9yX2Rlc2NfczJtcHMxM19idWNrKDEwLCBNSU5fNTAwX01WLCAgU1RFUF82XzI1X01WLCAweDEwKSwKKwlyZWd1bGF0b3JfZGVzY19zMm1wczEzX2J1Y2s3KDcsICBNSU5fNTAwX01WLCAgU1RFUF82XzI1X01WLCAweDEwKSwKKwlyZWd1bGF0b3JfZGVzY19zMm1wczEzX2J1Y2s4XzEwKDgsICBNSU5fMTAwMF9NViwgU1RFUF8xMl81X01WLCAweDIwKSwKKwlyZWd1bGF0b3JfZGVzY19zMm1wczEzX2J1Y2s4XzEwKDksICBNSU5fMTAwMF9NViwgU1RFUF8xMl81X01WLCAweDIwKSwKKwlyZWd1bGF0b3JfZGVzY19zMm1wczEzX2J1Y2s4XzEwKDEwLCBNSU5fNTAwX01WLCAgU1RFUF82XzI1X01WLCAweDEwKSwKIH07CiAKIHN0YXRpYyBpbnQgczJtcHMxNF9yZWd1bGF0b3JfZW5hYmxlKHN0cnVjdCByZWd1bGF0b3JfZGV2ICpyZGV2KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ydGMvcnRjLXM1bS5jIGIvZHJpdmVycy9ydGMvcnRjLXM1bS5jCmluZGV4IGI1ZTdjNDYuLjg5YWMxZDUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcnRjL3J0Yy1zNW0uYworKysgYi9kcml2ZXJzL3J0Yy9ydGMtczVtLmMKQEAgLTgzMiw2ICs4MzIsNyBAQAogc3RhdGljIGNvbnN0IHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2VfaWQgczVtX3J0Y19pZFtdID0gewogCXsgInM1bS1ydGMiLAkJUzVNODc2N1ggfSwKIAl7ICJzMm1wczE0LXJ0YyIsCVMyTVBTMTRYIH0sCisJeyB9LAogfTsKIAogc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kcml2ZXIgczVtX3J0Y19kcml2ZXIgPSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3MzOTAvbmV0L3FldGhfY29yZV9tYWluLmMgYi9kcml2ZXJzL3MzOTAvbmV0L3FldGhfY29yZV9tYWluLmMKaW5kZXggZjQwN2UzNy4uNjQyYzc3YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zMzkwL25ldC9xZXRoX2NvcmVfbWFpbi5jCisrKyBiL2RyaXZlcnMvczM5MC9uZXQvcWV0aF9jb3JlX21haW4uYwpAQCAtMTc4NCw2ICsxNzg0LDggQEAKIAlRRVRIX0RCRl9URVhUKFNFVFVQLCAyLCAiaWR4YW5zd3IiKTsKIAljYXJkID0gQ0FSRF9GUk9NX0NERVYoY2hhbm5lbC0+Y2N3ZGV2KTsKIAlpb2IgPSBxZXRoX2dldF9idWZmZXIoY2hhbm5lbCk7CisJaWYgKCFpb2IpCisJCXJldHVybiAtRU5PTUVNOwogCWlvYi0+Y2FsbGJhY2sgPSBpZHhfcmVwbHlfY2I7CiAJbWVtY3B5KCZjaGFubmVsLT5jY3csIFJFQURfQ0NXLCBzaXplb2Yoc3RydWN0IGNjdzEpKTsKIAljaGFubmVsLT5jY3cuY291bnQgPSBRRVRIX0JVRlNJWkU7CkBAIC0xODM0LDYgKzE4MzYsOCBAQAogCVFFVEhfREJGX1RFWFQoU0VUVVAsIDIsICJpZHhhY3RjaCIpOwogCiAJaW9iID0gcWV0aF9nZXRfYnVmZmVyKGNoYW5uZWwpOworCWlmICghaW9iKQorCQlyZXR1cm4gLUVOT01FTTsKIAlpb2ItPmNhbGxiYWNrID0gaWR4X3JlcGx5X2NiOwogCW1lbWNweSgmY2hhbm5lbC0+Y2N3LCBXUklURV9DQ1csIHNpemVvZihzdHJ1Y3QgY2N3MSkpOwogCWNoYW5uZWwtPmNjdy5jb3VudCA9IElEWF9BQ1RJVkFURV9TSVpFOwpAQCAtMjAyMSwxMCArMjAyNSwzNiBAQAogfQogRVhQT1JUX1NZTUJPTF9HUEwocWV0aF9wcmVwYXJlX2NvbnRyb2xfZGF0YSk7CiAKKy8qKgorICogcWV0aF9zZW5kX2NvbnRyb2xfZGF0YSgpIC0Jc2VuZCBjb250cm9sIGNvbW1hbmQgdG8gdGhlIGNhcmQKKyAqIEBjYXJkOgkJCXFldGhfY2FyZCBzdHJ1Y3R1cmUgcG9pbnRlcgorICogQGxlbjoJCQlzaXplIG9mIHRoZSBjb21tYW5kIGJ1ZmZlcgorICogQGlvYjoJCQlxZXRoX2NtZF9idWZmZXIgcG9pbnRlcgorICogQHJlcGx5X2NiOgkJCWNhbGxiYWNrIGZ1bmN0aW9uIHBvaW50ZXIKKyAqIEBjYl9jYXJkOgkJCXBvaW50ZXIgdG8gdGhlIHFldGhfY2FyZCBzdHJ1Y3R1cmUKKyAqIEBjYl9yZXBseToJCQlwb2ludGVyIHRvIHRoZSBxZXRoX3JlcGx5IHN0cnVjdHVyZQorICogQGNiX2NtZDoJCQlwb2ludGVyIHRvIHRoZSBvcmlnaW5hbCBpb2IgZm9yIG5vbi1JUEEKKyAqCQkJCWNvbW1hbmRzLCBvciB0byB0aGUgcWV0aF9pcGFfY21kIHN0cnVjdHVyZQorICoJCQkJZm9yIHRoZSBJUEEgY29tbWFuZHMuCisgKiBAcmVwbHlfcGFyYW06CQlwcml2YXRlIHBvaW50ZXIgcGFzc2VkIHRvIHRoZSBjYWxsYmFjaworICoKKyAqIFJldHVybnMgdGhlIHZhbHVlIG9mIHRoZSBgcmV0dXJuX2NvZGUnIGZpZWxkIG9mIHRoZSByZXNwb25zZQorICogYmxvY2sgcmV0dXJuZWQgZnJvbSB0aGUgaGFyZHdhcmUsIG9yIG90aGVyIGVycm9yIGluZGljYXRpb24uCisgKiBWYWx1ZSBvZiB6ZXJvIGluZGljYXRlcyBzdWNjZXNzZnVsIGV4ZWN1dGlvbiBvZiB0aGUgY29tbWFuZC4KKyAqCisgKiBDYWxsYmFjayBmdW5jdGlvbiBnZXRzIGNhbGxlZCBvbmUgb3IgbW9yZSB0aW1lcywgd2l0aCBjYl9jbWQKKyAqIHBvaW50aW5nIHRvIHRoZSByZXNwb25zZSByZXR1cm5lZCBieSB0aGUgaGFyZHdhcmUuIENhbGxiYWNrCisgKiBmdW5jdGlvbiBtdXN0IHJldHVybiBub24temVybyBpZiBtb3JlIHJlcGx5IGJsb2NrcyBhcmUgZXhwZWN0ZWQsCisgKiBhbmQgemVybyBpZiB0aGUgbGFzdCBvciBvbmx5IHJlcGx5IGJsb2NrIGlzIHJlY2VpdmVkLiBDYWxsYmFjaworICogZnVuY3Rpb24gY2FuIGdldCB0aGUgdmFsdWUgb2YgdGhlIHJlcGx5X3BhcmFtIHBvaW50ZXIgZnJvbSB0aGUKKyAqIGZpZWxkICdwYXJhbScgb2YgdGhlIHN0cnVjdHVyZSBxZXRoX3JlcGx5LgorICovCisKIGludCBxZXRoX3NlbmRfY29udHJvbF9kYXRhKHN0cnVjdCBxZXRoX2NhcmQgKmNhcmQsIGludCBsZW4sCiAJCXN0cnVjdCBxZXRoX2NtZF9idWZmZXIgKmlvYiwKLQkJaW50ICgqcmVwbHlfY2IpKHN0cnVjdCBxZXRoX2NhcmQgKiwgc3RydWN0IHFldGhfcmVwbHkgKiwKLQkJCXVuc2lnbmVkIGxvbmcpLAorCQlpbnQgKCpyZXBseV9jYikoc3RydWN0IHFldGhfY2FyZCAqY2JfY2FyZCwKKwkJCQlzdHJ1Y3QgcWV0aF9yZXBseSAqY2JfcmVwbHksCisJCQkJdW5zaWduZWQgbG9uZyBjYl9jbWQpLAogCQl2b2lkICpyZXBseV9wYXJhbSkKIHsKIAlpbnQgcmM7CkBAIC0yOTE0LDkgKzI5NDQsMTYgQEAKIAlzdHJ1Y3QgcWV0aF9jbWRfYnVmZmVyICppb2I7CiAJc3RydWN0IHFldGhfaXBhX2NtZCAqY21kOwogCi0JaW9iID0gcWV0aF93YWl0X2Zvcl9idWZmZXIoJmNhcmQtPndyaXRlKTsKLQljbWQgPSAoc3RydWN0IHFldGhfaXBhX2NtZCAqKShpb2ItPmRhdGErSVBBX1BEVV9IRUFERVJfU0laRSk7Ci0JcWV0aF9maWxsX2lwYWNtZF9oZWFkZXIoY2FyZCwgY21kLCBpcGFjbWQsIHByb3QpOworCWlvYiA9IHFldGhfZ2V0X2J1ZmZlcigmY2FyZC0+d3JpdGUpOworCWlmIChpb2IpIHsKKwkJY21kID0gKHN0cnVjdCBxZXRoX2lwYV9jbWQgKikoaW9iLT5kYXRhK0lQQV9QRFVfSEVBREVSX1NJWkUpOworCQlxZXRoX2ZpbGxfaXBhY21kX2hlYWRlcihjYXJkLCBjbWQsIGlwYWNtZCwgcHJvdCk7CisJfSBlbHNlIHsKKwkJZGV2X3dhcm4oJmNhcmQtPmdkZXYtPmRldiwKKwkJCSAiVGhlIHFldGggZHJpdmVyIHJhbiBvdXQgb2YgY2hhbm5lbCBjb21tYW5kIGJ1ZmZlcnNcbiIpOworCQlRRVRIX0RCRl9NRVNTQUdFKDEsICIlcyBUaGUgcWV0aCBkcml2ZXIgcmFuIG91dCBvZiBjaGFubmVsIGNvbW1hbmQgYnVmZmVycyIsCisJCQkJIGRldl9uYW1lKCZjYXJkLT5nZGV2LT5kZXYpKTsKKwl9CiAKIAlyZXR1cm4gaW9iOwogfQpAQCAtMjkzMiw2ICsyOTY5LDEyIEBACiB9CiBFWFBPUlRfU1lNQk9MX0dQTChxZXRoX3ByZXBhcmVfaXBhX2NtZCk7CiAKKy8qKgorICogcWV0aF9zZW5kX2lwYV9jbWQoKSAtIHNlbmQgYW4gSVBBIGNvbW1hbmQKKyAqCisgKiBTZWUgcWV0aF9zZW5kX2NvbnRyb2xfZGF0YSgpIGZvciBleHBsYW5hdGlvbiBvZiB0aGUgYXJndW1lbnRzLgorICovCisKIGludCBxZXRoX3NlbmRfaXBhX2NtZChzdHJ1Y3QgcWV0aF9jYXJkICpjYXJkLCBzdHJ1Y3QgcWV0aF9jbWRfYnVmZmVyICppb2IsCiAJCWludCAoKnJlcGx5X2NiKShzdHJ1Y3QgcWV0aF9jYXJkICosIHN0cnVjdCBxZXRoX3JlcGx5KiwKIAkJCXVuc2lnbmVkIGxvbmcpLApAQCAtMjk2OCw2ICszMDExLDggQEAKIAlRRVRIX0RCRl9URVhUKFNFVFVQLCAyLCAic3RydGxhbiIpOwogCiAJaW9iID0gcWV0aF9nZXRfaXBhY21kX2J1ZmZlcihjYXJkLCBJUEFfQ01EX1NUQVJUTEFOLCAwKTsKKwlpZiAoIWlvYikKKwkJcmV0dXJuIC1FTk9NRU07CiAJcmMgPSBxZXRoX3NlbmRfaXBhX2NtZChjYXJkLCBpb2IsIE5VTEwsIE5VTEwpOwogCXJldHVybiByYzsKIH0KQEAgLTMwMTMsMTEgKzMwNTgsMTMgQEAKIAogCWlvYiA9IHFldGhfZ2V0X2lwYWNtZF9idWZmZXIoY2FyZCwgSVBBX0NNRF9TRVRBREFQVEVSUEFSTVMsCiAJCQkJICAgICBRRVRIX1BST1RfSVBWNCk7Ci0JY21kID0gKHN0cnVjdCBxZXRoX2lwYV9jbWQgKikoaW9iLT5kYXRhK0lQQV9QRFVfSEVBREVSX1NJWkUpOwotCWNtZC0+ZGF0YS5zZXRhZGFwdGVycGFybXMuaGRyLmNtZGxlbmd0aCA9IGNtZGxlbjsKLQljbWQtPmRhdGEuc2V0YWRhcHRlcnBhcm1zLmhkci5jb21tYW5kX2NvZGUgPSBjb21tYW5kOwotCWNtZC0+ZGF0YS5zZXRhZGFwdGVycGFybXMuaGRyLnVzZWRfdG90YWwgPSAxOwotCWNtZC0+ZGF0YS5zZXRhZGFwdGVycGFybXMuaGRyLnNlcV9ubyA9IDE7CisJaWYgKGlvYikgeworCQljbWQgPSAoc3RydWN0IHFldGhfaXBhX2NtZCAqKShpb2ItPmRhdGErSVBBX1BEVV9IRUFERVJfU0laRSk7CisJCWNtZC0+ZGF0YS5zZXRhZGFwdGVycGFybXMuaGRyLmNtZGxlbmd0aCA9IGNtZGxlbjsKKwkJY21kLT5kYXRhLnNldGFkYXB0ZXJwYXJtcy5oZHIuY29tbWFuZF9jb2RlID0gY29tbWFuZDsKKwkJY21kLT5kYXRhLnNldGFkYXB0ZXJwYXJtcy5oZHIudXNlZF90b3RhbCA9IDE7CisJCWNtZC0+ZGF0YS5zZXRhZGFwdGVycGFybXMuaGRyLnNlcV9ubyA9IDE7CisJfQogCiAJcmV0dXJuIGlvYjsKIH0KQEAgLTMwMzAsNiArMzA3Nyw4IEBACiAJUUVUSF9DQVJEX1RFWFQoY2FyZCwgMywgInF1ZXJ5YWRwIik7CiAJaW9iID0gcWV0aF9nZXRfYWRhcHRlcl9jbWQoY2FyZCwgSVBBX1NFVEFEUF9RVUVSWV9DT01NQU5EU19TVVBQT1JURUQsCiAJCQkJICAgc2l6ZW9mKHN0cnVjdCBxZXRoX2lwYWNtZF9zZXRhZHBwYXJtcykpOworCWlmICghaW9iKQorCQlyZXR1cm4gLUVOT01FTTsKIAlyYyA9IHFldGhfc2VuZF9pcGFfY21kKGNhcmQsIGlvYiwgcWV0aF9xdWVyeV9zZXRhZGFwdGVycGFybXNfY2IsIE5VTEwpOwogCXJldHVybiByYzsKIH0KQEAgLTMwODAsNiArMzEyOSw4IEBACiAKIAlRRVRIX0RCRl9URVhUXyhTRVRVUCwgMiwgInFpcGFzc2klaSIsIHByb3QpOwogCWlvYiA9IHFldGhfZ2V0X2lwYWNtZF9idWZmZXIoY2FyZCwgSVBBX0NNRF9RSVBBU1NJU1QsIHByb3QpOworCWlmICghaW9iKQorCQlyZXR1cm4gLUVOT01FTTsKIAlyYyA9IHFldGhfc2VuZF9pcGFfY21kKGNhcmQsIGlvYiwgcWV0aF9xdWVyeV9pcGFzc2lzdHNfY2IsIE5VTEwpOwogCXJldHVybiByYzsKIH0KQEAgLTMxMTksNiArMzE3MCw4IEBACiAJCXJldHVybiAtRU5PTUVESVVNOwogCWlvYiA9IHFldGhfZ2V0X2FkYXB0ZXJfY21kKGNhcmQsIElQQV9TRVRBRFBfUVVFUllfU1dJVENIX0FUVFJJQlVURVMsCiAJCQkJc2l6ZW9mKHN0cnVjdCBxZXRoX2lwYWNtZF9zZXRhZHBwYXJtc19oZHIpKTsKKwlpZiAoIWlvYikKKwkJcmV0dXJuIC1FTk9NRU07CiAJcmV0dXJuIHFldGhfc2VuZF9pcGFfY21kKGNhcmQsIGlvYiwKIAkJCQlxZXRoX3F1ZXJ5X3N3aXRjaF9hdHRyaWJ1dGVzX2NiLCBzd19pbmZvKTsKIH0KQEAgLTMxNDYsNiArMzE5OSw4IEBACiAKIAlRRVRIX0RCRl9URVhUKFNFVFVQLCAyLCAicWRpYWdhc3MiKTsKIAlpb2IgPSBxZXRoX2dldF9pcGFjbWRfYnVmZmVyKGNhcmQsIElQQV9DTURfU0VUX0RJQUdfQVNTLCAwKTsKKwlpZiAoIWlvYikKKwkJcmV0dXJuIC1FTk9NRU07CiAJY21kID0gKHN0cnVjdCBxZXRoX2lwYV9jbWQgKikoaW9iLT5kYXRhK0lQQV9QRFVfSEVBREVSX1NJWkUpOwogCWNtZC0+ZGF0YS5kaWFnYXNzLnN1YmNtZF9sZW4gPSAxNjsKIAljbWQtPmRhdGEuZGlhZ2Fzcy5zdWJjbWQgPSBRRVRIX0RJQUdTX0NNRF9RVUVSWTsKQEAgLTMxOTcsNiArMzI1Miw4IEBACiAKIAlRRVRIX0RCRl9URVhUKFNFVFVQLCAyLCAiZGlhZ3RyYXAiKTsKIAlpb2IgPSBxZXRoX2dldF9pcGFjbWRfYnVmZmVyKGNhcmQsIElQQV9DTURfU0VUX0RJQUdfQVNTLCAwKTsKKwlpZiAoIWlvYikKKwkJcmV0dXJuIC1FTk9NRU07CiAJY21kID0gKHN0cnVjdCBxZXRoX2lwYV9jbWQgKikoaW9iLT5kYXRhK0lQQV9QRFVfSEVBREVSX1NJWkUpOwogCWNtZC0+ZGF0YS5kaWFnYXNzLnN1YmNtZF9sZW4gPSA4MDsKIAljbWQtPmRhdGEuZGlhZ2Fzcy5zdWJjbWQgPSBRRVRIX0RJQUdTX0NNRF9UUkFQOwpAQCAtNDE2Miw2ICs0MjE5LDggQEAKIAogCWlvYiA9IHFldGhfZ2V0X2FkYXB0ZXJfY21kKGNhcmQsIElQQV9TRVRBRFBfU0VUX1BST01JU0NfTU9ERSwKIAkJCXNpemVvZihzdHJ1Y3QgcWV0aF9pcGFjbWRfc2V0YWRwcGFybXMpKTsKKwlpZiAoIWlvYikKKwkJcmV0dXJuOwogCWNtZCA9IChzdHJ1Y3QgcWV0aF9pcGFfY21kICopKGlvYi0+ZGF0YSArIElQQV9QRFVfSEVBREVSX1NJWkUpOwogCWNtZC0+ZGF0YS5zZXRhZGFwdGVycGFybXMuZGF0YS5tb2RlID0gbW9kZTsKIAlxZXRoX3NlbmRfaXBhX2NtZChjYXJkLCBpb2IsIHFldGhfc2V0YWRwX3Byb21pc2NfbW9kZV9jYiwgTlVMTCk7CkBAIC00MjMyLDYgKzQyOTEsOCBAQAogCiAJaW9iID0gcWV0aF9nZXRfYWRhcHRlcl9jbWQoY2FyZCwgSVBBX1NFVEFEUF9BTFRFUl9NQUNfQUREUkVTUywKIAkJCQkgICBzaXplb2Yoc3RydWN0IHFldGhfaXBhY21kX3NldGFkcHBhcm1zKSk7CisJaWYgKCFpb2IpCisJCXJldHVybiAtRU5PTUVNOwogCWNtZCA9IChzdHJ1Y3QgcWV0aF9pcGFfY21kICopKGlvYi0+ZGF0YStJUEFfUERVX0hFQURFUl9TSVpFKTsKIAljbWQtPmRhdGEuc2V0YWRhcHRlcnBhcm1zLmRhdGEuY2hhbmdlX2FkZHIuY21kID0gQ0hBTkdFX0FERFJfUkVBRF9NQUM7CiAJY21kLT5kYXRhLnNldGFkYXB0ZXJwYXJtcy5kYXRhLmNoYW5nZV9hZGRyLmFkZHJfc2l6ZSA9IE9TQV9BRERSX0xFTjsKQEAgLTQzNDUsNiArNDQwNiw4IEBACiAJaW9iID0gcWV0aF9nZXRfYWRhcHRlcl9jbWQoY2FyZCwgSVBBX1NFVEFEUF9TRVRfQUNDRVNTX0NPTlRST0wsCiAJCQkJICAgc2l6ZW9mKHN0cnVjdCBxZXRoX2lwYWNtZF9zZXRhZHBwYXJtc19oZHIpICsKIAkJCQkgICBzaXplb2Yoc3RydWN0IHFldGhfc2V0X2FjY2Vzc19jdHJsKSk7CisJaWYgKCFpb2IpCisJCXJldHVybiAtRU5PTUVNOwogCWNtZCA9IChzdHJ1Y3QgcWV0aF9pcGFfY21kICopKGlvYi0+ZGF0YStJUEFfUERVX0hFQURFUl9TSVpFKTsKIAlhY2Nlc3NfY3RybF9yZXEgPSAmY21kLT5kYXRhLnNldGFkYXB0ZXJwYXJtcy5kYXRhLnNldF9hY2Nlc3NfY3RybDsKIAlhY2Nlc3NfY3RybF9yZXEtPnN1YmNtZF9jb2RlID0gaXNvbGF0aW9uOwpAQCAtNDU4OCw2ICs0NjUxLDEwIEBACiAKIAlpb2IgPSBxZXRoX2dldF9hZGFwdGVyX2NtZChjYXJkLCBJUEFfU0VUQURQX1NFVF9TTk1QX0NPTlRST0wsCiAJCQkJICAgUUVUSF9TTk1QX1NFVEFEUF9DTURMRU5HVEggKyByZXFfbGVuKTsKKwlpZiAoIWlvYikgeworCQlyYyA9IC1FTk9NRU07CisJCWdvdG8gb3V0OworCX0KIAljbWQgPSAoc3RydWN0IHFldGhfaXBhX2NtZCAqKShpb2ItPmRhdGErSVBBX1BEVV9IRUFERVJfU0laRSk7CiAJbWVtY3B5KCZjbWQtPmRhdGEuc2V0YWRhcHRlcnBhcm1zLmRhdGEuc25tcCwgJnVyZXEtPmNtZCwgcmVxX2xlbik7CiAJcmMgPSBxZXRoX3NlbmRfaXBhX3NubXBfY21kKGNhcmQsIGlvYiwgUUVUSF9TRVRBRFBfQkFTRV9MRU4gKyByZXFfbGVuLApAQCAtNDU5OSw3ICs0NjY2LDcgQEAKIAkJaWYgKGNvcHlfdG9fdXNlcih1ZGF0YSwgcWluZm8udWRhdGEsIHFpbmZvLnVkYXRhX2xlbikpCiAJCQlyYyA9IC1FRkFVTFQ7CiAJfQotCitvdXQ6CiAJa2ZyZWUodXJlcSk7CiAJa2ZyZWUocWluZm8udWRhdGEpOwogCXJldHVybiByYzsKQEAgLTQ2NzAsNiArNDczNywxMCBAQAogCWlvYiA9IHFldGhfZ2V0X2FkYXB0ZXJfY21kKGNhcmQsIElQQV9TRVRBRFBfUVVFUllfT0FULAogCQkJCSAgIHNpemVvZihzdHJ1Y3QgcWV0aF9pcGFjbWRfc2V0YWRwcGFybXNfaGRyKSArCiAJCQkJICAgc2l6ZW9mKHN0cnVjdCBxZXRoX3F1ZXJ5X29hdCkpOworCWlmICghaW9iKSB7CisJCXJjID0gLUVOT01FTTsKKwkJZ290byBvdXRfZnJlZTsKKwl9CiAJY21kID0gKHN0cnVjdCBxZXRoX2lwYV9jbWQgKikoaW9iLT5kYXRhK0lQQV9QRFVfSEVBREVSX1NJWkUpOwogCW9hdF9yZXEgPSAmY21kLT5kYXRhLnNldGFkYXB0ZXJwYXJtcy5kYXRhLnF1ZXJ5X29hdDsKIAlvYXRfcmVxLT5zdWJjbWRfY29kZSA9IG9hdF9kYXRhLmNvbW1hbmQ7CkBAIC00NzM1LDYgKzQ4MDYsOCBAQAogCQlyZXR1cm4gLUVPUE5PVFNVUFA7CiAJaW9iID0gcWV0aF9nZXRfYWRhcHRlcl9jbWQoY2FyZCwgSVBBX1NFVEFEUF9RVUVSWV9DQVJEX0lORk8sCiAJCXNpemVvZihzdHJ1Y3QgcWV0aF9pcGFjbWRfc2V0YWRwcGFybXNfaGRyKSk7CisJaWYgKCFpb2IpCisJCXJldHVybiAtRU5PTUVNOwogCXJldHVybiBxZXRoX3NlbmRfaXBhX2NtZChjYXJkLCBpb2IsIHFldGhfcXVlcnlfY2FyZF9pbmZvX2NiLAogCQkJCQkodm9pZCAqKWNhcnJpZXJfaW5mbyk7CiB9CkBAIC01MDYwLDExICs1MTMzLDIzIEBACiAJY2FyZC0+b3B0aW9ucy5hZHAuc3VwcG9ydGVkX2Z1bmNzID0gMDsKIAljYXJkLT5vcHRpb25zLnNicC5zdXBwb3J0ZWRfZnVuY3MgPSAwOwogCWNhcmQtPmluZm8uZGlhZ2Fzc19zdXBwb3J0ID0gMDsKLQlxZXRoX3F1ZXJ5X2lwYXNzaXN0cyhjYXJkLCBRRVRIX1BST1RfSVBWNCk7Ci0JaWYgKHFldGhfaXNfc3VwcG9ydGVkKGNhcmQsIElQQV9TRVRBREFQVEVSUEFSTVMpKQotCQlxZXRoX3F1ZXJ5X3NldGFkYXB0ZXJwYXJtcyhjYXJkKTsKLQlpZiAocWV0aF9hZHBfc3VwcG9ydGVkKGNhcmQsIElQQV9TRVRBRFBfU0VUX0RJQUdfQVNTSVNUKSkKLQkJcWV0aF9xdWVyeV9zZXRkaWFnYXNzKGNhcmQpOworCXJjID0gcWV0aF9xdWVyeV9pcGFzc2lzdHMoY2FyZCwgUUVUSF9QUk9UX0lQVjQpOworCWlmIChyYyA9PSAtRU5PTUVNKQorCQlnb3RvIG91dDsKKwlpZiAocWV0aF9pc19zdXBwb3J0ZWQoY2FyZCwgSVBBX1NFVEFEQVBURVJQQVJNUykpIHsKKwkJcmMgPSBxZXRoX3F1ZXJ5X3NldGFkYXB0ZXJwYXJtcyhjYXJkKTsKKwkJaWYgKHJjIDwgMCkgeworCQkJUUVUSF9EQkZfVEVYVF8oU0VUVVAsIDIsICI2ZXJyJWQiLCByYyk7CisJCQlnb3RvIG91dDsKKwkJfQorCX0KKwlpZiAocWV0aF9hZHBfc3VwcG9ydGVkKGNhcmQsIElQQV9TRVRBRFBfU0VUX0RJQUdfQVNTSVNUKSkgeworCQlyYyA9IHFldGhfcXVlcnlfc2V0ZGlhZ2FzcyhjYXJkKTsKKwkJaWYgKHJjIDwgMCkgeworCQkJUUVUSF9EQkZfVEVYVF8oU0VUVVAsIDIsICI3ZXJyJWQiLCByYyk7CisJCQlnb3RvIG91dDsKKwkJfQorCX0KIAlyZXR1cm4gMDsKIG91dDoKIAlkZXZfd2FybigmY2FyZC0+Z2Rldi0+ZGV2LCAiVGhlIHFldGggZGV2aWNlIGRyaXZlciBmYWlsZWQgdG8gcmVjb3ZlciAiCmRpZmYgLS1naXQgYS9kcml2ZXJzL3MzOTAvbmV0L3FldGhfbDJfbWFpbi5jIGIvZHJpdmVycy9zMzkwL25ldC9xZXRoX2wyX21haW4uYwppbmRleCBkMDJjZDFhLi5jZTg3YWU3IDEwMDY0NAotLS0gYS9kcml2ZXJzL3MzOTAvbmV0L3FldGhfbDJfbWFpbi5jCisrKyBiL2RyaXZlcnMvczM5MC9uZXQvcWV0aF9sMl9tYWluLmMKQEAgLTI3LDEwICsyNyw3IEBACiBzdGF0aWMgaW50IHFldGhfbDJfc3RvcChzdHJ1Y3QgbmV0X2RldmljZSAqKTsKIHN0YXRpYyBpbnQgcWV0aF9sMl9zZW5kX2RlbG1hYyhzdHJ1Y3QgcWV0aF9jYXJkICosIF9fdTggKik7CiBzdGF0aWMgaW50IHFldGhfbDJfc2VuZF9zZXRkZWxtYWMoc3RydWN0IHFldGhfY2FyZCAqLCBfX3U4ICosCi0JCQkgICBlbnVtIHFldGhfaXBhX2NtZHMsCi0JCQkgICBpbnQgKCpyZXBseV9jYikgKHN0cnVjdCBxZXRoX2NhcmQgKiwKLQkJCQkJICAgIHN0cnVjdCBxZXRoX3JlcGx5KiwKLQkJCQkJICAgIHVuc2lnbmVkIGxvbmcpKTsKKwkJCSAgIGVudW0gcWV0aF9pcGFfY21kcyk7CiBzdGF0aWMgdm9pZCBxZXRoX2wyX3NldF9tdWx0aWNhc3RfbGlzdChzdHJ1Y3QgbmV0X2RldmljZSAqKTsKIHN0YXRpYyBpbnQgcWV0aF9sMl9yZWNvdmVyKHZvaWQgKik7CiBzdGF0aWMgdm9pZCBxZXRoX2JyaWRnZXBvcnRfcXVlcnlfc3VwcG9ydChzdHJ1Y3QgcWV0aF9jYXJkICpjYXJkKTsKQEAgLTEzMCw1NiArMTI3LDcxIEBACiAJcmV0dXJuIG5kZXY7CiB9CiAKLXN0YXRpYyBpbnQgcWV0aF9sMl9zZW5kX3NldGdyb3VwbWFjX2NiKHN0cnVjdCBxZXRoX2NhcmQgKmNhcmQsCi0JCQkJc3RydWN0IHFldGhfcmVwbHkgKnJlcGx5LAotCQkJCXVuc2lnbmVkIGxvbmcgZGF0YSkKK3N0YXRpYyBpbnQgcWV0aF9zZXRkZWxfbWFrZXJjKHN0cnVjdCBxZXRoX2NhcmQgKmNhcmQsIGludCByZXRjb2RlKQogewotCXN0cnVjdCBxZXRoX2lwYV9jbWQgKmNtZDsKLQlfX3U4ICptYWM7CisJaW50IHJjOwogCi0JUUVUSF9DQVJEX1RFWFQoY2FyZCwgMiwgIkwyU2dtYWNiIik7Ci0JY21kID0gKHN0cnVjdCBxZXRoX2lwYV9jbWQgKikgZGF0YTsKLQltYWMgPSAmY21kLT5kYXRhLnNldGRlbG1hYy5tYWNbMF07Ci0JLyogTUFDIGFscmVhZHkgcmVnaXN0ZXJlZCwgbmVlZGVkIGluIGNvdXBsZS91bmNvdXBsZSBjYXNlICovCi0JaWYgKGNtZC0+aGRyLnJldHVybl9jb2RlID09ICBJUEFfUkNfTDJfRFVQX01BQykgewotCQlRRVRIX0RCRl9NRVNTQUdFKDIsICJHcm91cCBNQUMgJXBNIGFscmVhZHkgZXhpc3Rpbmcgb24gJXMgXG4iLAotCQkJICBtYWMsIFFFVEhfQ0FSRF9JRk5BTUUoY2FyZCkpOwotCQljbWQtPmhkci5yZXR1cm5fY29kZSA9IDA7CisJaWYgKHJldGNvZGUpCisJCVFFVEhfQ0FSRF9URVhUXyhjYXJkLCAyLCAiZXJyJTA0eCIsIHJldGNvZGUpOworCXN3aXRjaCAocmV0Y29kZSkgeworCWNhc2UgSVBBX1JDX1NVQ0NFU1M6CisJCXJjID0gMDsKKwkJYnJlYWs7CisJY2FzZSBJUEFfUkNfTDJfVU5TVVBQT1JURURfQ01EOgorCQlyYyA9IC1FTk9TWVM7CisJCWJyZWFrOworCWNhc2UgSVBBX1JDX0wyX0FERFJfVEFCTEVfRlVMTDoKKwkJcmMgPSAtRU5PU1BDOworCQlicmVhazsKKwljYXNlIElQQV9SQ19MMl9EVVBfTUFDOgorCWNhc2UgSVBBX1JDX0wyX0RVUF9MQVlFUjNfTUFDOgorCQlyYyA9IC1FRVhJU1Q7CisJCWJyZWFrOworCWNhc2UgSVBBX1JDX0wyX01BQ19OT1RfQVVUSF9CWV9IWVA6CisJY2FzZSBJUEFfUkNfTDJfTUFDX05PVF9BVVRIX0JZX0FEUDoKKwkJcmMgPSAtRVBFUk07CisJCWJyZWFrOworCWNhc2UgSVBBX1JDX0wyX01BQ19OT1RfRk9VTkQ6CisJCXJjID0gLUVOT0VOVDsKKwkJYnJlYWs7CisJY2FzZSAtRU5PTUVNOgorCQlyYyA9IC1FTk9NRU07CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCXJjID0gLUVJTzsKKwkJYnJlYWs7CiAJfQotCWlmIChjbWQtPmhkci5yZXR1cm5fY29kZSkKLQkJUUVUSF9EQkZfTUVTU0FHRSgyLCAiQ291bGQgbm90IHNldCBncm91cCBNQUMgJXBNIG9uICVzOiAleFxuIiwKLQkJCSAgbWFjLCBRRVRIX0NBUkRfSUZOQU1FKGNhcmQpLCBjbWQtPmhkci5yZXR1cm5fY29kZSk7Ci0JcmV0dXJuIDA7CisJcmV0dXJuIHJjOwogfQogCiBzdGF0aWMgaW50IHFldGhfbDJfc2VuZF9zZXRncm91cG1hYyhzdHJ1Y3QgcWV0aF9jYXJkICpjYXJkLCBfX3U4ICptYWMpCiB7CisJaW50IHJjOworCiAJUUVUSF9DQVJEX1RFWFQoY2FyZCwgMiwgIkwyU2dtYWMiKTsKLQlyZXR1cm4gcWV0aF9sMl9zZW5kX3NldGRlbG1hYyhjYXJkLCBtYWMsIElQQV9DTURfU0VUR01BQywKLQkJCQkJICBxZXRoX2wyX3NlbmRfc2V0Z3JvdXBtYWNfY2IpOwotfQotCi1zdGF0aWMgaW50IHFldGhfbDJfc2VuZF9kZWxncm91cG1hY19jYihzdHJ1Y3QgcWV0aF9jYXJkICpjYXJkLAotCQkJCXN0cnVjdCBxZXRoX3JlcGx5ICpyZXBseSwKLQkJCQl1bnNpZ25lZCBsb25nIGRhdGEpCi17Ci0Jc3RydWN0IHFldGhfaXBhX2NtZCAqY21kOwotCV9fdTggKm1hYzsKLQotCVFFVEhfQ0FSRF9URVhUKGNhcmQsIDIsICJMMkRnbWFjYiIpOwotCWNtZCA9IChzdHJ1Y3QgcWV0aF9pcGFfY21kICopIGRhdGE7Ci0JbWFjID0gJmNtZC0+ZGF0YS5zZXRkZWxtYWMubWFjWzBdOwotCWlmIChjbWQtPmhkci5yZXR1cm5fY29kZSkKLQkJUUVUSF9EQkZfTUVTU0FHRSgyLCAiQ291bGQgbm90IGRlbGV0ZSBncm91cCBNQUMgJXBNIG9uICVzOiAleFxuIiwKLQkJCSAgbWFjLCBRRVRIX0NBUkRfSUZOQU1FKGNhcmQpLCBjbWQtPmhkci5yZXR1cm5fY29kZSk7Ci0JcmV0dXJuIDA7CisJcmMgPSBxZXRoX3NldGRlbF9tYWtlcmMoY2FyZCwgcWV0aF9sMl9zZW5kX3NldGRlbG1hYyhjYXJkLCBtYWMsCisJCQkJCUlQQV9DTURfU0VUR01BQykpOworCWlmIChyYyA9PSAtRUVYSVNUKQorCQlRRVRIX0RCRl9NRVNTQUdFKDIsICJHcm91cCBNQUMgJXBNIGFscmVhZHkgZXhpc3Rpbmcgb24gJXNcbiIsCisJCQltYWMsIFFFVEhfQ0FSRF9JRk5BTUUoY2FyZCkpOworCWVsc2UgaWYgKHJjKQorCQlRRVRIX0RCRl9NRVNTQUdFKDIsICJDb3VsZCBub3Qgc2V0IGdyb3VwIE1BQyAlcE0gb24gJXM6ICVkXG4iLAorCQkJbWFjLCBRRVRIX0NBUkRfSUZOQU1FKGNhcmQpLCByYyk7CisJcmV0dXJuIHJjOwogfQogCiBzdGF0aWMgaW50IHFldGhfbDJfc2VuZF9kZWxncm91cG1hYyhzdHJ1Y3QgcWV0aF9jYXJkICpjYXJkLCBfX3U4ICptYWMpCiB7CisJaW50IHJjOworCiAJUUVUSF9DQVJEX1RFWFQoY2FyZCwgMiwgIkwyRGdtYWMiKTsKLQlyZXR1cm4gcWV0aF9sMl9zZW5kX3NldGRlbG1hYyhjYXJkLCBtYWMsIElQQV9DTURfREVMR01BQywKLQkJCQkJICBxZXRoX2wyX3NlbmRfZGVsZ3JvdXBtYWNfY2IpOworCXJjID0gcWV0aF9zZXRkZWxfbWFrZXJjKGNhcmQsIHFldGhfbDJfc2VuZF9zZXRkZWxtYWMoY2FyZCwgbWFjLAorCQkJCQlJUEFfQ01EX0RFTEdNQUMpKTsKKwlpZiAocmMpCisJCVFFVEhfREJGX01FU1NBR0UoMiwKKwkJCSJDb3VsZCBub3QgZGVsZXRlIGdyb3VwIE1BQyAlcE0gb24gJXM6ICVkXG4iLAorCQkJbWFjLCBRRVRIX0NBUkRfSUZOQU1FKGNhcmQpLCByYyk7CisJcmV0dXJuIHJjOwogfQogCiBzdGF0aWMgdm9pZCBxZXRoX2wyX2FkZF9tYyhzdHJ1Y3QgcWV0aF9jYXJkICpjYXJkLCBfX3U4ICptYWMsIGludCB2bWFjKQpAQCAtMTk3LDEwICsyMDksMTEgQEAKIAltYy0+aXNfdm1hYyA9IHZtYWM7CiAKIAlpZiAodm1hYykgewotCQlyYyA9IHFldGhfbDJfc2VuZF9zZXRkZWxtYWMoY2FyZCwgbWFjLCBJUEFfQ01EX1NFVFZNQUMsCi0JCQkJCU5VTEwpOworCQlyYyA9IHFldGhfc2V0ZGVsX21ha2VyYyhjYXJkLAorCQkJcWV0aF9sMl9zZW5kX3NldGRlbG1hYyhjYXJkLCBtYWMsIElQQV9DTURfU0VUVk1BQykpOwogCX0gZWxzZSB7Ci0JCXJjID0gcWV0aF9sMl9zZW5kX3NldGdyb3VwbWFjKGNhcmQsIG1hYyk7CisJCXJjID0gcWV0aF9zZXRkZWxfbWFrZXJjKGNhcmQsCisJCQlxZXRoX2wyX3NlbmRfc2V0Z3JvdXBtYWMoY2FyZCwgbWFjKSk7CiAJfQogCiAJaWYgKCFyYykKQEAgLTIxOCw3ICsyMzEsNyBAQAogCQlpZiAoZGVsKSB7CiAJCQlpZiAobWMtPmlzX3ZtYWMpCiAJCQkJcWV0aF9sMl9zZW5kX3NldGRlbG1hYyhjYXJkLCBtYy0+bWNfYWRkciwKLQkJCQkJSVBBX0NNRF9ERUxWTUFDLCBOVUxMKTsKKwkJCQkJSVBBX0NNRF9ERUxWTUFDKTsKIAkJCWVsc2UKIAkJCQlxZXRoX2wyX3NlbmRfZGVsZ3JvdXBtYWMoY2FyZCwgbWMtPm1jX2FkZHIpOwogCQl9CkBAIC0yOTEsNiArMzA0LDggQEAKIAogCVFFVEhfQ0FSRF9URVhUXyhjYXJkLCA0LCAiTDJzZHYleCIsIGlwYWNtZCk7CiAJaW9iID0gcWV0aF9nZXRfaXBhY21kX2J1ZmZlcihjYXJkLCBpcGFjbWQsIFFFVEhfUFJPVF9JUFY0KTsKKwlpZiAoIWlvYikKKwkJcmV0dXJuIC1FTk9NRU07CiAJY21kID0gKHN0cnVjdCBxZXRoX2lwYV9jbWQgKikoaW9iLT5kYXRhK0lQQV9QRFVfSEVBREVSX1NJWkUpOwogCWNtZC0+ZGF0YS5zZXRkZWx2bGFuLnZsYW5faWQgPSBpOwogCXJldHVybiBxZXRoX3NlbmRfaXBhX2NtZChjYXJkLCBpb2IsCkBAIC0zMTMsNiArMzI4LDcgQEAKIHsKIAlzdHJ1Y3QgcWV0aF9jYXJkICpjYXJkID0gZGV2LT5tbF9wcml2OwogCXN0cnVjdCBxZXRoX3ZsYW5fdmlkICppZDsKKwlpbnQgcmM7CiAKIAlRRVRIX0NBUkRfVEVYVF8oY2FyZCwgNCwgImFpZDolZCIsIHZpZCk7CiAJaWYgKCF2aWQpCkBAIC0zMjgsNyArMzQ0LDExIEBACiAJaWQgPSBrbWFsbG9jKHNpemVvZihzdHJ1Y3QgcWV0aF92bGFuX3ZpZCksIEdGUF9BVE9NSUMpOwogCWlmIChpZCkgewogCQlpZC0+dmlkID0gdmlkOwotCQlxZXRoX2wyX3NlbmRfc2V0ZGVsdmxhbihjYXJkLCB2aWQsIElQQV9DTURfU0VUVkxBTik7CisJCXJjID0gcWV0aF9sMl9zZW5kX3NldGRlbHZsYW4oY2FyZCwgdmlkLCBJUEFfQ01EX1NFVFZMQU4pOworCQlpZiAocmMpIHsKKwkJCWtmcmVlKGlkKTsKKwkJCXJldHVybiByYzsKKwkJfQogCQlzcGluX2xvY2tfYmgoJmNhcmQtPnZsYW5sb2NrKTsKIAkJbGlzdF9hZGRfdGFpbCgmaWQtPmxpc3QsICZjYXJkLT52aWRfbGlzdCk7CiAJCXNwaW5fdW5sb2NrX2JoKCZjYXJkLT52bGFubG9jayk7CkBAIC0zNDMsNiArMzYzLDcgQEAKIHsKIAlzdHJ1Y3QgcWV0aF92bGFuX3ZpZCAqaWQsICp0bXBpZCA9IE5VTEw7CiAJc3RydWN0IHFldGhfY2FyZCAqY2FyZCA9IGRldi0+bWxfcHJpdjsKKwlpbnQgcmMgPSAwOwogCiAJUUVUSF9DQVJEX1RFWFRfKGNhcmQsIDQsICJraWQ6JWQiLCB2aWQpOwogCWlmIChjYXJkLT5pbmZvLnR5cGUgPT0gUUVUSF9DQVJEX1RZUEVfT1NNKSB7CkBAIC0zNjMsMTEgKzM4NCwxMSBAQAogCX0KIAlzcGluX3VubG9ja19iaCgmY2FyZC0+dmxhbmxvY2spOwogCWlmICh0bXBpZCkgewotCQlxZXRoX2wyX3NlbmRfc2V0ZGVsdmxhbihjYXJkLCB2aWQsIElQQV9DTURfREVMVkxBTik7CisJCXJjID0gcWV0aF9sMl9zZW5kX3NldGRlbHZsYW4oY2FyZCwgdmlkLCBJUEFfQ01EX0RFTFZMQU4pOwogCQlrZnJlZSh0bXBpZCk7CiAJfQogCXFldGhfbDJfc2V0X211bHRpY2FzdF9saXN0KGNhcmQtPmRldik7Ci0JcmV0dXJuIDA7CisJcmV0dXJuIHJjOwogfQogCiBzdGF0aWMgaW50IHFldGhfbDJfc3RvcF9jYXJkKHN0cnVjdCBxZXRoX2NhcmQgKmNhcmQsIGludCByZWNvdmVyeV9tb2RlKQpAQCAtNTM5LDkxICs1NjAsNjIgQEAKIH0KIAogc3RhdGljIGludCBxZXRoX2wyX3NlbmRfc2V0ZGVsbWFjKHN0cnVjdCBxZXRoX2NhcmQgKmNhcmQsIF9fdTggKm1hYywKLQkJCSAgIGVudW0gcWV0aF9pcGFfY21kcyBpcGFjbWQsCi0JCQkgICBpbnQgKCpyZXBseV9jYikgKHN0cnVjdCBxZXRoX2NhcmQgKiwKLQkJCQkJICAgIHN0cnVjdCBxZXRoX3JlcGx5KiwKLQkJCQkJICAgIHVuc2lnbmVkIGxvbmcpKQorCQkJICAgZW51bSBxZXRoX2lwYV9jbWRzIGlwYWNtZCkKIHsKIAlzdHJ1Y3QgcWV0aF9pcGFfY21kICpjbWQ7CiAJc3RydWN0IHFldGhfY21kX2J1ZmZlciAqaW9iOwogCiAJUUVUSF9DQVJEX1RFWFQoY2FyZCwgMiwgIkwyc2RtYWMiKTsKIAlpb2IgPSBxZXRoX2dldF9pcGFjbWRfYnVmZmVyKGNhcmQsIGlwYWNtZCwgUUVUSF9QUk9UX0lQVjQpOworCWlmICghaW9iKQorCQlyZXR1cm4gLUVOT01FTTsKIAljbWQgPSAoc3RydWN0IHFldGhfaXBhX2NtZCAqKShpb2ItPmRhdGErSVBBX1BEVV9IRUFERVJfU0laRSk7CiAJY21kLT5kYXRhLnNldGRlbG1hYy5tYWNfbGVuZ3RoID0gT1NBX0FERFJfTEVOOwogCW1lbWNweSgmY21kLT5kYXRhLnNldGRlbG1hYy5tYWMsIG1hYywgT1NBX0FERFJfTEVOKTsKLQlyZXR1cm4gcWV0aF9zZW5kX2lwYV9jbWQoY2FyZCwgaW9iLCByZXBseV9jYiwgTlVMTCk7Ci19Ci0KLXN0YXRpYyBpbnQgcWV0aF9sMl9zZW5kX3NldG1hY19jYihzdHJ1Y3QgcWV0aF9jYXJkICpjYXJkLAotCQkJICAgc3RydWN0IHFldGhfcmVwbHkgKnJlcGx5LAotCQkJICAgdW5zaWduZWQgbG9uZyBkYXRhKQotewotCXN0cnVjdCBxZXRoX2lwYV9jbWQgKmNtZDsKLQotCVFFVEhfQ0FSRF9URVhUKGNhcmQsIDIsICJMMlNtYWNjYiIpOwotCWNtZCA9IChzdHJ1Y3QgcWV0aF9pcGFfY21kICopIGRhdGE7Ci0JaWYgKGNtZC0+aGRyLnJldHVybl9jb2RlKSB7Ci0JCVFFVEhfQ0FSRF9URVhUXyhjYXJkLCAyLCAiTDJlciV4IiwgY21kLT5oZHIucmV0dXJuX2NvZGUpOwotCQljYXJkLT5pbmZvLm1hY19iaXRzICY9IH5RRVRIX0xBWUVSMl9NQUNfUkVHSVNURVJFRDsKLQkJc3dpdGNoIChjbWQtPmhkci5yZXR1cm5fY29kZSkgewotCQljYXNlIElQQV9SQ19MMl9EVVBfTUFDOgotCQljYXNlIElQQV9SQ19MMl9EVVBfTEFZRVIzX01BQzoKLQkJCWRldl93YXJuKCZjYXJkLT5nZGV2LT5kZXYsCi0JCQkJIk1BQyBhZGRyZXNzICVwTSBhbHJlYWR5IGV4aXN0c1xuIiwKLQkJCQljbWQtPmRhdGEuc2V0ZGVsbWFjLm1hYyk7Ci0JCQlicmVhazsKLQkJY2FzZSBJUEFfUkNfTDJfTUFDX05PVF9BVVRIX0JZX0hZUDoKLQkJY2FzZSBJUEFfUkNfTDJfTUFDX05PVF9BVVRIX0JZX0FEUDoKLQkJCWRldl93YXJuKCZjYXJkLT5nZGV2LT5kZXYsCi0JCQkJIk1BQyBhZGRyZXNzICVwTSBpcyBub3QgYXV0aG9yaXplZFxuIiwKLQkJCQljbWQtPmRhdGEuc2V0ZGVsbWFjLm1hYyk7Ci0JCQlicmVhazsKLQkJZGVmYXVsdDoKLQkJCWJyZWFrOwotCQl9Ci0JfSBlbHNlIHsKLQkJY2FyZC0+aW5mby5tYWNfYml0cyB8PSBRRVRIX0xBWUVSMl9NQUNfUkVHSVNURVJFRDsKLQkJbWVtY3B5KGNhcmQtPmRldi0+ZGV2X2FkZHIsIGNtZC0+ZGF0YS5zZXRkZWxtYWMubWFjLAotCQkgICAgICAgT1NBX0FERFJfTEVOKTsKLQkJZGV2X2luZm8oJmNhcmQtPmdkZXYtPmRldiwKLQkJCSJNQUMgYWRkcmVzcyAlcE0gc3VjY2Vzc2Z1bGx5IHJlZ2lzdGVyZWQgb24gZGV2aWNlICVzXG4iLAotCQkJY2FyZC0+ZGV2LT5kZXZfYWRkciwgY2FyZC0+ZGV2LT5uYW1lKTsKLQl9Ci0JcmV0dXJuIDA7CisJcmV0dXJuIHFldGhfc2VuZF9pcGFfY21kKGNhcmQsIGlvYiwgTlVMTCwgTlVMTCk7CiB9CiAKIHN0YXRpYyBpbnQgcWV0aF9sMl9zZW5kX3NldG1hYyhzdHJ1Y3QgcWV0aF9jYXJkICpjYXJkLCBfX3U4ICptYWMpCiB7CisJaW50IHJjOworCiAJUUVUSF9DQVJEX1RFWFQoY2FyZCwgMiwgIkwyU2V0bWFjIik7Ci0JcmV0dXJuIHFldGhfbDJfc2VuZF9zZXRkZWxtYWMoY2FyZCwgbWFjLCBJUEFfQ01EX1NFVFZNQUMsCi0JCQkJCSAgcWV0aF9sMl9zZW5kX3NldG1hY19jYik7Ci19Ci0KLXN0YXRpYyBpbnQgcWV0aF9sMl9zZW5kX2RlbG1hY19jYihzdHJ1Y3QgcWV0aF9jYXJkICpjYXJkLAotCQkJICAgc3RydWN0IHFldGhfcmVwbHkgKnJlcGx5LAotCQkJICAgdW5zaWduZWQgbG9uZyBkYXRhKQotewotCXN0cnVjdCBxZXRoX2lwYV9jbWQgKmNtZDsKLQotCVFFVEhfQ0FSRF9URVhUKGNhcmQsIDIsICJMMkRtYWNjYiIpOwotCWNtZCA9IChzdHJ1Y3QgcWV0aF9pcGFfY21kICopIGRhdGE7Ci0JaWYgKGNtZC0+aGRyLnJldHVybl9jb2RlKSB7Ci0JCVFFVEhfQ0FSRF9URVhUXyhjYXJkLCAyLCAiZXJyJWQiLCBjbWQtPmhkci5yZXR1cm5fY29kZSk7Ci0JCXJldHVybiAwOworCXJjID0gcWV0aF9zZXRkZWxfbWFrZXJjKGNhcmQsIHFldGhfbDJfc2VuZF9zZXRkZWxtYWMoY2FyZCwgbWFjLAorCQkJCQlJUEFfQ01EX1NFVFZNQUMpKTsKKwlpZiAocmMgPT0gMCkgeworCQljYXJkLT5pbmZvLm1hY19iaXRzIHw9IFFFVEhfTEFZRVIyX01BQ19SRUdJU1RFUkVEOworCQltZW1jcHkoY2FyZC0+ZGV2LT5kZXZfYWRkciwgbWFjLCBPU0FfQUREUl9MRU4pOworCQlkZXZfaW5mbygmY2FyZC0+Z2Rldi0+ZGV2LAorCQkJIk1BQyBhZGRyZXNzICVwTSBzdWNjZXNzZnVsbHkgcmVnaXN0ZXJlZCBvbiBkZXZpY2UgJXNcbiIsCisJCQljYXJkLT5kZXYtPmRldl9hZGRyLCBjYXJkLT5kZXYtPm5hbWUpOworCX0gZWxzZSB7CisJCWNhcmQtPmluZm8ubWFjX2JpdHMgJj0gflFFVEhfTEFZRVIyX01BQ19SRUdJU1RFUkVEOworCQlzd2l0Y2ggKHJjKSB7CisJCWNhc2UgLUVFWElTVDoKKwkJCWRldl93YXJuKCZjYXJkLT5nZGV2LT5kZXYsCisJCQkJIk1BQyBhZGRyZXNzICVwTSBhbHJlYWR5IGV4aXN0c1xuIiwgbWFjKTsKKwkJCWJyZWFrOworCQljYXNlIC1FUEVSTToKKwkJCWRldl93YXJuKCZjYXJkLT5nZGV2LT5kZXYsCisJCQkJIk1BQyBhZGRyZXNzICVwTSBpcyBub3QgYXV0aG9yaXplZFxuIiwgbWFjKTsKKwkJCWJyZWFrOworCQl9CiAJfQotCWNhcmQtPmluZm8ubWFjX2JpdHMgJj0gflFFVEhfTEFZRVIyX01BQ19SRUdJU1RFUkVEOwotCi0JcmV0dXJuIDA7CisJcmV0dXJuIHJjOwogfQogCiBzdGF0aWMgaW50IHFldGhfbDJfc2VuZF9kZWxtYWMoc3RydWN0IHFldGhfY2FyZCAqY2FyZCwgX191OCAqbWFjKQogeworCWludCByYzsKKwogCVFFVEhfQ0FSRF9URVhUKGNhcmQsIDIsICJMMkRlbG1hYyIpOwogCWlmICghKGNhcmQtPmluZm8ubWFjX2JpdHMgJiBRRVRIX0xBWUVSMl9NQUNfUkVHSVNURVJFRCkpCiAJCXJldHVybiAwOwotCXJldHVybiBxZXRoX2wyX3NlbmRfc2V0ZGVsbWFjKGNhcmQsIG1hYywgSVBBX0NNRF9ERUxWTUFDLAotCQkJCQkgIHFldGhfbDJfc2VuZF9kZWxtYWNfY2IpOworCXJjID0gcWV0aF9zZXRkZWxfbWFrZXJjKGNhcmQsIHFldGhfbDJfc2VuZF9zZXRkZWxtYWMoY2FyZCwgbWFjLAorCQkJCQlJUEFfQ01EX0RFTFZNQUMpKTsKKwlpZiAocmMgPT0gMCkKKwkJY2FyZC0+aW5mby5tYWNfYml0cyAmPSB+UUVUSF9MQVlFUjJfTUFDX1JFR0lTVEVSRUQ7CisJcmV0dXJuIHJjOwogfQogCiBzdGF0aWMgaW50IHFldGhfbDJfcmVxdWVzdF9pbml0aWFsX21hYyhzdHJ1Y3QgcWV0aF9jYXJkICpjYXJkKQpAQCAtNjUxLDcgKzY0Myw3IEBACiAJCWlmIChyYykgewogCQkJUUVUSF9EQkZfTUVTU0FHRSgyLCAiY291bGRuJ3QgZ2V0IE1BQyBhZGRyZXNzIG9uICIKIAkJCQkiZGV2aWNlICVzOiB4JXhcbiIsIENBUkRfQlVTX0lEKGNhcmQpLCByYyk7Ci0JCQlRRVRIX0RCRl9URVhUXyhTRVRVUCwgMiwgIjFlcnIlZCIsIHJjKTsKKwkJCVFFVEhfREJGX1RFWFRfKFNFVFVQLCAyLCAiMWVyciUwNHgiLCByYyk7CiAJCQlyZXR1cm4gcmM7CiAJCX0KIAkJUUVUSF9EQkZfSEVYKFNFVFVQLCAyLCBjYXJkLT5kZXYtPmRldl9hZGRyLCBPU0FfQUREUl9MRU4pOwpAQCAtNjg3LDcgKzY3OSw3IEBACiAJCXJldHVybiAtRVJFU1RBUlRTWVM7CiAJfQogCXJjID0gcWV0aF9sMl9zZW5kX2RlbG1hYyhjYXJkLCAmY2FyZC0+ZGV2LT5kZXZfYWRkclswXSk7Ci0JaWYgKCFyYyB8fCAocmMgPT0gSVBBX1JDX0wyX01BQ19OT1RfRk9VTkQpKQorCWlmICghcmMgfHwgKHJjID09IC1FTk9FTlQpKQogCQlyYyA9IHFldGhfbDJfc2VuZF9zZXRtYWMoY2FyZCwgYWRkci0+c2FfZGF0YSk7CiAJcmV0dXJuIHJjID8gLUVJTlZBTCA6IDA7CiB9CkBAIC05OTYsNyArOTg4LDcgQEAKIAlyZWNvdmVyX2ZsYWcgPSBjYXJkLT5zdGF0ZTsKIAlyYyA9IHFldGhfY29yZV9oYXJkc2V0dXBfY2FyZChjYXJkKTsKIAlpZiAocmMpIHsKLQkJUUVUSF9EQkZfVEVYVF8oU0VUVVAsIDIsICIyZXJyJWQiLCByYyk7CisJCVFFVEhfREJGX1RFWFRfKFNFVFVQLCAyLCAiMmVyciUwNHgiLCByYyk7CiAJCXJjID0gLUVOT0RFVjsKIAkJZ290byBvdXRfcmVtb3ZlOwogCX0KQEAgLTE3MzAsNiArMTcyMiw4IEBACiAKIAlRRVRIX0NBUkRfVEVYVChjYXJkLCAyLCAiYnJxc3VwcG8iKTsKIAlpb2IgPSBxZXRoX2dldF9pcGFjbWRfYnVmZmVyKGNhcmQsIElQQV9DTURfU0VUQlJJREdFUE9SVCwgMCk7CisJaWYgKCFpb2IpCisJCXJldHVybjsKIAljbWQgPSAoc3RydWN0IHFldGhfaXBhX2NtZCAqKShpb2ItPmRhdGErSVBBX1BEVV9IRUFERVJfU0laRSk7CiAJY21kLT5kYXRhLnNicC5oZHIuY21kbGVuZ3RoID0KIAkJc2l6ZW9mKHN0cnVjdCBxZXRoX2lwYWNtZF9zYnBfaGRyKSArCkBAIC0xODA1LDYgKzE3OTksOCBAQAogCWlmICghKGNhcmQtPm9wdGlvbnMuc2JwLnN1cHBvcnRlZF9mdW5jcyAmIElQQV9TQlBfUVVFUllfQlJJREdFX1BPUlRTKSkKIAkJcmV0dXJuIC1FT1BOT1RTVVBQOwogCWlvYiA9IHFldGhfZ2V0X2lwYWNtZF9idWZmZXIoY2FyZCwgSVBBX0NNRF9TRVRCUklER0VQT1JULCAwKTsKKwlpZiAoIWlvYikKKwkJcmV0dXJuIC1FTk9NRU07CiAJY21kID0gKHN0cnVjdCBxZXRoX2lwYV9jbWQgKikoaW9iLT5kYXRhK0lQQV9QRFVfSEVBREVSX1NJWkUpOwogCWNtZC0+ZGF0YS5zYnAuaGRyLmNtZGxlbmd0aCA9CiAJCXNpemVvZihzdHJ1Y3QgcWV0aF9pcGFjbWRfc2JwX2hkcik7CkBAIC0xODE3LDkgKzE4MTMsNyBAQAogCWlmIChyYykKIAkJcmV0dXJuIHJjOwogCXJjID0gcWV0aF9icmlkZ2Vwb3J0X21ha2VyYyhjYXJkLCAmY2JjdGwsIElQQV9TQlBfUVVFUllfQlJJREdFX1BPUlRTKTsKLQlpZiAocmMpCi0JCXJldHVybiByYzsKLQlyZXR1cm4gMDsKKwlyZXR1cm4gcmM7CiB9CiBFWFBPUlRfU1lNQk9MX0dQTChxZXRoX2JyaWRnZXBvcnRfcXVlcnlfcG9ydHMpOwogCkBAIC0xODczLDYgKzE4NjcsOCBAQAogCWlmICghKGNhcmQtPm9wdGlvbnMuc2JwLnN1cHBvcnRlZF9mdW5jcyAmIHNldGNtZCkpCiAJCXJldHVybiAtRU9QTk9UU1VQUDsKIAlpb2IgPSBxZXRoX2dldF9pcGFjbWRfYnVmZmVyKGNhcmQsIElQQV9DTURfU0VUQlJJREdFUE9SVCwgMCk7CisJaWYgKCFpb2IpCisJCXJldHVybiAtRU5PTUVNOwogCWNtZCA9IChzdHJ1Y3QgcWV0aF9pcGFfY21kICopKGlvYi0+ZGF0YStJUEFfUERVX0hFQURFUl9TSVpFKTsKIAljbWQtPmRhdGEuc2JwLmhkci5jbWRsZW5ndGggPSBjbWRsZW5ndGg7CiAJY21kLT5kYXRhLnNicC5oZHIuY29tbWFuZF9jb2RlID0gc2V0Y21kOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zMzkwL25ldC9xZXRoX2wzX21haW4uYyBiL2RyaXZlcnMvczM5MC9uZXQvcWV0aF9sM19tYWluLmMKaW5kZXggNjI1MjI3YWQuLmUyYTBlZTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvczM5MC9uZXQvcWV0aF9sM19tYWluLmMKKysrIGIvZHJpdmVycy9zMzkwL25ldC9xZXRoX2wzX21haW4uYwpAQCAtNTQ5LDYgKzU0OSw4IEBACiAJUUVUSF9DQVJEX1RFWFQoY2FyZCwgNCwgInNldGRlbG1jIik7CiAKIAlpb2IgPSBxZXRoX2dldF9pcGFjbWRfYnVmZmVyKGNhcmQsIGlwYWNtZCwgYWRkci0+cHJvdG8pOworCWlmICghaW9iKQorCQlyZXR1cm4gLUVOT01FTTsKIAljbWQgPSAoc3RydWN0IHFldGhfaXBhX2NtZCAqKShpb2ItPmRhdGErSVBBX1BEVV9IRUFERVJfU0laRSk7CiAJbWVtY3B5KCZjbWQtPmRhdGEuc2V0ZGVsaXBtLm1hYywgYWRkci0+bWFjLCBPU0FfQUREUl9MRU4pOwogCWlmIChhZGRyLT5wcm90byA9PSBRRVRIX1BST1RfSVBWNikKQEAgLTU4OCw2ICs1OTAsOCBAQAogCVFFVEhfQ0FSRF9URVhUXyhjYXJkLCA0LCAiZmxhZ3MlMDJYIiwgZmxhZ3MpOwogCiAJaW9iID0gcWV0aF9nZXRfaXBhY21kX2J1ZmZlcihjYXJkLCBpcGFjbWQsIGFkZHItPnByb3RvKTsKKwlpZiAoIWlvYikKKwkJcmV0dXJuIC1FTk9NRU07CiAJY21kID0gKHN0cnVjdCBxZXRoX2lwYV9jbWQgKikoaW9iLT5kYXRhK0lQQV9QRFVfSEVBREVSX1NJWkUpOwogCWlmIChhZGRyLT5wcm90byA9PSBRRVRIX1BST1RfSVBWNikgewogCQltZW1jcHkoY21kLT5kYXRhLnNldGRlbGlwNi5pcF9hZGRyLCAmYWRkci0+dS5hNi5hZGRyLApAQCAtNjE2LDYgKzYyMCw4IEBACiAKIAlRRVRIX0NBUkRfVEVYVChjYXJkLCA0LCAic2V0cm91dGciKTsKIAlpb2IgPSBxZXRoX2dldF9pcGFjbWRfYnVmZmVyKGNhcmQsIElQQV9DTURfU0VUUlRHLCBwcm90KTsKKwlpZiAoIWlvYikKKwkJcmV0dXJuIC1FTk9NRU07CiAJY21kID0gKHN0cnVjdCBxZXRoX2lwYV9jbWQgKikoaW9iLT5kYXRhK0lQQV9QRFVfSEVBREVSX1NJWkUpOwogCWNtZC0+ZGF0YS5zZXRydGcudHlwZSA9ICh0eXBlKTsKIAlyYyA9IHFldGhfc2VuZF9pcGFfY21kKGNhcmQsIGlvYiwgTlVMTCwgTlVMTCk7CkBAIC0xMDQ5LDEyICsxMDU1LDE0IEBACiAJUUVUSF9DQVJEX1RFWFQoY2FyZCwgNCwgImdldGFzc2NtIik7CiAJaW9iID0gcWV0aF9nZXRfaXBhY21kX2J1ZmZlcihjYXJkLCBJUEFfQ01EX1NFVEFTU1BBUk1TLCBwcm90KTsKIAotCWNtZCA9IChzdHJ1Y3QgcWV0aF9pcGFfY21kICopKGlvYi0+ZGF0YStJUEFfUERVX0hFQURFUl9TSVpFKTsKLQljbWQtPmRhdGEuc2V0YXNzcGFybXMuaGRyLmFzc2lzdF9ubyA9IGlwYV9mdW5jOwotCWNtZC0+ZGF0YS5zZXRhc3NwYXJtcy5oZHIubGVuZ3RoID0gOCArIGxlbjsKLQljbWQtPmRhdGEuc2V0YXNzcGFybXMuaGRyLmNvbW1hbmRfY29kZSA9IGNtZF9jb2RlOwotCWNtZC0+ZGF0YS5zZXRhc3NwYXJtcy5oZHIucmV0dXJuX2NvZGUgPSAwOwotCWNtZC0+ZGF0YS5zZXRhc3NwYXJtcy5oZHIuc2VxX25vID0gMDsKKwlpZiAoaW9iKSB7CisJCWNtZCA9IChzdHJ1Y3QgcWV0aF9pcGFfY21kICopKGlvYi0+ZGF0YStJUEFfUERVX0hFQURFUl9TSVpFKTsKKwkJY21kLT5kYXRhLnNldGFzc3Bhcm1zLmhkci5hc3Npc3Rfbm8gPSBpcGFfZnVuYzsKKwkJY21kLT5kYXRhLnNldGFzc3Bhcm1zLmhkci5sZW5ndGggPSA4ICsgbGVuOworCQljbWQtPmRhdGEuc2V0YXNzcGFybXMuaGRyLmNvbW1hbmRfY29kZSA9IGNtZF9jb2RlOworCQljbWQtPmRhdGEuc2V0YXNzcGFybXMuaGRyLnJldHVybl9jb2RlID0gMDsKKwkJY21kLT5kYXRhLnNldGFzc3Bhcm1zLmhkci5zZXFfbm8gPSAwOworCX0KIAogCXJldHVybiBpb2I7CiB9CkBAIC0xMDkwLDYgKzEwOTgsOCBAQAogCVFFVEhfQ0FSRF9URVhUKGNhcmQsIDQsICJzaW1hc3NwNiIpOwogCWlvYiA9IHFldGhfbDNfZ2V0X3NldGFzc3Bhcm1zX2NtZChjYXJkLCBpcGFfZnVuYywgY21kX2NvZGUsCiAJCQkJICAgICAgIDAsIFFFVEhfUFJPVF9JUFY2KTsKKwlpZiAoIWlvYikKKwkJcmV0dXJuIC1FTk9NRU07CiAJcmMgPSBxZXRoX2wzX3NlbmRfc2V0YXNzcGFybXMoY2FyZCwgaW9iLCAwLCAwLAogCQkJCSAgIHFldGhfbDNfZGVmYXVsdF9zZXRhc3NwYXJtc19jYiwgTlVMTCk7CiAJcmV0dXJuIHJjOwpAQCAtMTEwOCw2ICsxMTE4LDggQEAKIAkJbGVuZ3RoID0gc2l6ZW9mKF9fdTMyKTsKIAlpb2IgPSBxZXRoX2wzX2dldF9zZXRhc3NwYXJtc19jbWQoY2FyZCwgaXBhX2Z1bmMsIGNtZF9jb2RlLAogCQkJCSAgICAgICBsZW5ndGgsIFFFVEhfUFJPVF9JUFY0KTsKKwlpZiAoIWlvYikKKwkJcmV0dXJuIC1FTk9NRU07CiAJcmMgPSBxZXRoX2wzX3NlbmRfc2V0YXNzcGFybXMoY2FyZCwgaW9iLCBsZW5ndGgsIGRhdGEsCiAJCQkJICAgcWV0aF9sM19kZWZhdWx0X3NldGFzc3Bhcm1zX2NiLCBOVUxMKTsKIAlyZXR1cm4gcmM7CkBAIC0xNDk0LDYgKzE1MDYsOCBAQAogCiAJaW9iID0gcWV0aF9nZXRfaXBhY21kX2J1ZmZlcihjYXJkLCBJUEFfQ01EX0NSRUFURV9BRERSLAogCQkJCSAgICAgUUVUSF9QUk9UX0lQVjYpOworCWlmICghaW9iKQorCQlyZXR1cm4gLUVOT01FTTsKIAljbWQgPSAoc3RydWN0IHFldGhfaXBhX2NtZCAqKShpb2ItPmRhdGErSVBBX1BEVV9IRUFERVJfU0laRSk7CiAJKigoX191MTYgKikgJmNtZC0+ZGF0YS5jcmVhdGVfZGVzdHJveV9hZGRyLnVuaXF1ZV9pZFs2XSkgPQogCQkJY2FyZC0+aW5mby51bmlxdWVfaWQ7CkBAIC0xNTM3LDYgKzE1NTEsOCBAQAogCiAJaW9iID0gcWV0aF9nZXRfaXBhY21kX2J1ZmZlcihjYXJkLCBJUEFfQ01EX0NSRUFURV9BRERSLAogCQkJCSAgICAgUUVUSF9QUk9UX0lQVjYpOworCWlmICghaW9iKQorCQlyZXR1cm4gLUVOT01FTTsKIAljbWQgPSAoc3RydWN0IHFldGhfaXBhX2NtZCAqKShpb2ItPmRhdGErSVBBX1BEVV9IRUFERVJfU0laRSk7CiAJKigoX191MTYgKikgJmNtZC0+ZGF0YS5jcmVhdGVfZGVzdHJveV9hZGRyLnVuaXF1ZV9pZFs2XSkgPQogCQkJY2FyZC0+aW5mby51bmlxdWVfaWQ7CkBAIC0xNjExLDYgKzE2MjcsOCBAQAogCVFFVEhfREJGX1RFWFQoU0VUVVAsIDIsICJkaWFndHJhYyIpOwogCiAJaW9iID0gcWV0aF9nZXRfaXBhY21kX2J1ZmZlcihjYXJkLCBJUEFfQ01EX1NFVF9ESUFHX0FTUywgMCk7CisJaWYgKCFpb2IpCisJCXJldHVybiAtRU5PTUVNOwogCWNtZCA9IChzdHJ1Y3QgcWV0aF9pcGFfY21kICopKGlvYi0+ZGF0YStJUEFfUERVX0hFQURFUl9TSVpFKTsKIAljbWQtPmRhdGEuZGlhZ2Fzcy5zdWJjbWRfbGVuID0gMTY7CiAJY21kLT5kYXRhLmRpYWdhc3Muc3ViY21kID0gUUVUSF9ESUFHU19DTURfVFJBQ0U7CkBAIC0yNDQyLDYgKzI0NjAsOCBAQAogCQkJSVBBX0NNRF9BU1NfQVJQX1FVRVJZX0lORk8sCiAJCQlzaXplb2Yoc3RydWN0IHFldGhfYXJwX3F1ZXJ5X2RhdGEpIC0gc2l6ZW9mKGNoYXIpLAogCQkJcHJvdCk7CisJaWYgKCFpb2IpCisJCXJldHVybiAtRU5PTUVNOwogCWNtZCA9IChzdHJ1Y3QgcWV0aF9pcGFfY21kICopKGlvYi0+ZGF0YStJUEFfUERVX0hFQURFUl9TSVpFKTsKIAljbWQtPmRhdGEuc2V0YXNzcGFybXMuZGF0YS5xdWVyeV9hcnAucmVxdWVzdF9iaXRzID0gMHgwMDBGOwogCWNtZC0+ZGF0YS5zZXRhc3NwYXJtcy5kYXRhLnF1ZXJ5X2FycC5yZXBseV9iaXRzID0gMDsKQEAgLTI1MzUsNiArMjU1NSw4IEBACiAJCQkJICAgICAgIElQQV9DTURfQVNTX0FSUF9BRERfRU5UUlksCiAJCQkJICAgICAgIHNpemVvZihzdHJ1Y3QgcWV0aF9hcnBfY2FjaGVfZW50cnkpLAogCQkJCSAgICAgICBRRVRIX1BST1RfSVBWNCk7CisJaWYgKCFpb2IpCisJCXJldHVybiAtRU5PTUVNOwogCXJjID0gcWV0aF9sM19zZW5kX3NldGFzc3Bhcm1zKGNhcmQsIGlvYiwKIAkJCQkgICBzaXplb2Yoc3RydWN0IHFldGhfYXJwX2NhY2hlX2VudHJ5KSwKIAkJCQkgICAodW5zaWduZWQgbG9uZykgZW50cnksCkBAIC0yNTc0LDYgKzI1OTYsOCBAQAogCQkJCSAgICAgICBJUEFfQ01EX0FTU19BUlBfUkVNT1ZFX0VOVFJZLAogCQkJCSAgICAgICAxMiwKIAkJCQkgICAgICAgUUVUSF9QUk9UX0lQVjQpOworCWlmICghaW9iKQorCQlyZXR1cm4gLUVOT01FTTsKIAlyYyA9IHFldGhfbDNfc2VuZF9zZXRhc3NwYXJtcyhjYXJkLCBpb2IsCiAJCQkJICAgMTIsICh1bnNpZ25lZCBsb25nKWJ1ZiwKIAkJCQkgICBxZXRoX2wzX2RlZmF1bHRfc2V0YXNzcGFybXNfY2IsIE5VTEwpOwpAQCAtMzI2Miw2ICszMjg2LDggQEAKIAogc3RhdGljIGludCBxZXRoX2wzX3NldHVwX25ldGRldihzdHJ1Y3QgcWV0aF9jYXJkICpjYXJkKQogeworCWludCByYzsKKwogCWlmIChjYXJkLT5pbmZvLnR5cGUgPT0gUUVUSF9DQVJEX1RZUEVfT1NEIHx8CiAJICAgIGNhcmQtPmluZm8udHlwZSA9PSBRRVRIX0NBUkRfVFlQRV9PU1gpIHsKIAkJaWYgKChjYXJkLT5pbmZvLmxpbmtfdHlwZSA9PSBRRVRIX0xJTktfVFlQRV9MQU5FX1RSKSB8fApAQCAtMzI5Myw3ICszMzE5LDkgQEAKIAkJCXJldHVybiAtRU5PREVWOwogCQljYXJkLT5kZXYtPmZsYWdzIHw9IElGRl9OT0FSUDsKIAkJY2FyZC0+ZGV2LT5uZXRkZXZfb3BzID0gJnFldGhfbDNfbmV0ZGV2X29wczsKLQkJcWV0aF9sM19pcWRfcmVhZF9pbml0aWFsX21hYyhjYXJkKTsKKwkJcmMgPSBxZXRoX2wzX2lxZF9yZWFkX2luaXRpYWxfbWFjKGNhcmQpOworCQlpZiAocmMpCisJCQlyZXR1cm4gcmM7CiAJCWlmIChjYXJkLT5vcHRpb25zLmhzdWlkWzBdKQogCQkJbWVtY3B5KGNhcmQtPmRldi0+cGVybV9hZGRyLCBjYXJkLT5vcHRpb25zLmhzdWlkLCA5KTsKIAl9IGVsc2UKQEAgLTMzNjAsNyArMzM4OCw3IEBACiAJcmVjb3Zlcl9mbGFnID0gY2FyZC0+c3RhdGU7CiAJcmMgPSBxZXRoX2NvcmVfaGFyZHNldHVwX2NhcmQoY2FyZCk7CiAJaWYgKHJjKSB7Ci0JCVFFVEhfREJGX1RFWFRfKFNFVFVQLCAyLCAiMmVyciVkIiwgcmMpOworCQlRRVRIX0RCRl9URVhUXyhTRVRVUCwgMiwgIjJlcnIlMDR4IiwgcmMpOwogCQlyYyA9IC1FTk9ERVY7CiAJCWdvdG8gb3V0X3JlbW92ZTsKIAl9CkBAIC0zNDAxLDcgKzM0MjksNyBAQAogY29udGluOgogCXJjID0gcWV0aF9sM19zZXRhZGFwdGVyX3Bhcm1zKGNhcmQpOwogCWlmIChyYykKLQkJUUVUSF9EQkZfVEVYVF8oU0VUVVAsIDIsICIyZXJyJWQiLCByYyk7CisJCVFFVEhfREJGX1RFWFRfKFNFVFVQLCAyLCAiMmVyciUwNHgiLCByYyk7CiAJaWYgKCFjYXJkLT5vcHRpb25zLnNuaWZmZXIpIHsKIAkJcmMgPSBxZXRoX2wzX3N0YXJ0X2lwYXNzaXN0cyhjYXJkKTsKIAkJaWYgKHJjKSB7CkBAIC0zNDEwLDEwICszNDM4LDEwIEBACiAJCX0KIAkJcmMgPSBxZXRoX2wzX3NldHJvdXRpbmdfdjQoY2FyZCk7CiAJCWlmIChyYykKLQkJCVFFVEhfREJGX1RFWFRfKFNFVFVQLCAyLCAiNGVyciVkIiwgcmMpOworCQkJUUVUSF9EQkZfVEVYVF8oU0VUVVAsIDIsICI0ZXJyJTA0eCIsIHJjKTsKIAkJcmMgPSBxZXRoX2wzX3NldHJvdXRpbmdfdjYoY2FyZCk7CiAJCWlmIChyYykKLQkJCVFFVEhfREJGX1RFWFRfKFNFVFVQLCAyLCAiNWVyciVkIiwgcmMpOworCQkJUUVUSF9EQkZfVEVYVF8oU0VUVVAsIDIsICI1ZXJyJTA0eCIsIHJjKTsKIAl9CiAJbmV0aWZfdHhfZGlzYWJsZShjYXJkLT5kZXYpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvZGV2aWNlX2hhbmRsZXIvc2NzaV9kaC5jIGIvZHJpdmVycy9zY3NpL2RldmljZV9oYW5kbGVyL3Njc2lfZGguYwppbmRleCAxZGJhNjJjLi4xZWZlYmM5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvZGV2aWNlX2hhbmRsZXIvc2NzaV9kaC5jCisrKyBiL2RyaXZlcnMvc2NzaS9kZXZpY2VfaGFuZGxlci9zY3NpX2RoLmMKQEAgLTEzNiwxMSArMTM2LDEyIEBACiAJc3RydWN0IHNjc2lfZGV2aWNlX2hhbmRsZXIgKnNjc2lfZGggPSBzY3NpX2RoX2RhdGEtPnNjc2lfZGg7CiAJc3RydWN0IHNjc2lfZGV2aWNlICpzZGV2ID0gc2NzaV9kaF9kYXRhLT5zZGV2OwogCisJc2NzaV9kaC0+ZGV0YWNoKHNkZXYpOworCiAJc3Bpbl9sb2NrX2lycShzZGV2LT5yZXF1ZXN0X3F1ZXVlLT5xdWV1ZV9sb2NrKTsKIAlzZGV2LT5zY3NpX2RoX2RhdGEgPSBOVUxMOwogCXNwaW5fdW5sb2NrX2lycShzZGV2LT5yZXF1ZXN0X3F1ZXVlLT5xdWV1ZV9sb2NrKTsKIAotCXNjc2lfZGgtPmRldGFjaChzZGV2KTsKIAlzZGV2X3ByaW50ayhLRVJOX05PVElDRSwgc2RldiwgIiVzOiBEZXRhY2hlZFxuIiwgc2NzaV9kaC0+bmFtZSk7CiAJbW9kdWxlX3B1dChzY3NpX2RoLT5tb2R1bGUpOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2lwci5jIGIvZHJpdmVycy9zY3NpL2lwci5jCmluZGV4IGRmNGUyN2MuLjkyMTk5NTMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9pcHIuYworKysgYi9kcml2ZXJzL3Njc2kvaXByLmMKQEAgLTY4Myw2ICs2ODMsNyBAQAogCWlwcl9yZWluaXRfaXByX2NtbmQoaXByX2NtZCk7CiAJaXByX2NtZC0+dS5zY3JhdGNoID0gMDsKIAlpcHJfY21kLT5zaWJsaW5nID0gTlVMTDsKKwlpcHJfY21kLT5laF9jb21wID0gTlVMTDsKIAlpcHJfY21kLT5mYXN0X2RvbmUgPSBmYXN0X2RvbmU7CiAJaW5pdF90aW1lcigmaXByX2NtZC0+dGltZXIpOwogfQpAQCAtODQ4LDYgKzg0OSw4IEBACiAKIAlzY3NpX2RtYV91bm1hcChpcHJfY21kLT5zY3NpX2NtZCk7CiAJc2NzaV9jbWQtPnNjc2lfZG9uZShzY3NpX2NtZCk7CisJaWYgKGlwcl9jbWQtPmVoX2NvbXApCisJCWNvbXBsZXRlKGlwcl9jbWQtPmVoX2NvbXApOwogCWxpc3RfYWRkX3RhaWwoJmlwcl9jbWQtPnF1ZXVlLCAmaXByX2NtZC0+aHJycS0+aHJycV9mcmVlX3EpOwogfQogCkBAIC00ODExLDYgKzQ4MTQsODQgQEAKIAlyZXR1cm4gcmM7CiB9CiAKKy8qKgorICogaXByX21hdGNoX2x1biAtIE1hdGNoIGZ1bmN0aW9uIGZvciBzcGVjaWZpZWQgTFVOCisgKiBAaXByX2NtZDoJaXByIGNvbW1hbmQgc3RydWN0CisgKiBAZGV2aWNlOgkJZGV2aWNlIHRvIG1hdGNoIChzZGV2KQorICoKKyAqIFJldHVybnM6CisgKgkxIGlmIGNvbW1hbmQgbWF0Y2hlcyBzZGV2IC8gMCBpZiBjb21tYW5kIGRvZXMgbm90IG1hdGNoIHNkZXYKKyAqKi8KK3N0YXRpYyBpbnQgaXByX21hdGNoX2x1bihzdHJ1Y3QgaXByX2NtbmQgKmlwcl9jbWQsIHZvaWQgKmRldmljZSkKK3sKKwlpZiAoaXByX2NtZC0+c2NzaV9jbWQgJiYgaXByX2NtZC0+c2NzaV9jbWQtPmRldmljZSA9PSBkZXZpY2UpCisJCXJldHVybiAxOworCXJldHVybiAwOworfQorCisvKioKKyAqIGlwcl93YWl0X2Zvcl9vcHMgLSBXYWl0IGZvciBtYXRjaGluZyBjb21tYW5kcyB0byBjb21wbGV0ZQorICogQGlwcl9jbWQ6CWlwciBjb21tYW5kIHN0cnVjdAorICogQGRldmljZToJCWRldmljZSB0byBtYXRjaCAoc2RldikKKyAqIEBtYXRjaDoJCW1hdGNoIGZ1bmN0aW9uIHRvIHVzZQorICoKKyAqIFJldHVybnM6CisgKglTVUNDRVNTIC8gRkFJTEVECisgKiovCitzdGF0aWMgaW50IGlwcl93YWl0X2Zvcl9vcHMoc3RydWN0IGlwcl9pb2FfY2ZnICppb2FfY2ZnLCB2b2lkICpkZXZpY2UsCisJCQkgICAgaW50ICgqbWF0Y2gpKHN0cnVjdCBpcHJfY21uZCAqLCB2b2lkICopKQoreworCXN0cnVjdCBpcHJfY21uZCAqaXByX2NtZDsKKwlpbnQgd2FpdDsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCXN0cnVjdCBpcHJfaHJyX3F1ZXVlICpocnJxOworCXNpZ25lZCBsb25nIHRpbWVvdXQgPSBJUFJfQUJPUlRfVEFTS19USU1FT1VUOworCURFQ0xBUkVfQ09NUExFVElPTl9PTlNUQUNLKGNvbXApOworCisJRU5URVI7CisJZG8geworCQl3YWl0ID0gMDsKKworCQlmb3JfZWFjaF9ocnJxKGhycnEsIGlvYV9jZmcpIHsKKwkJCXNwaW5fbG9ja19pcnFzYXZlKGhycnEtPmxvY2ssIGZsYWdzKTsKKwkJCWxpc3RfZm9yX2VhY2hfZW50cnkoaXByX2NtZCwgJmhycnEtPmhycnFfcGVuZGluZ19xLCBxdWV1ZSkgeworCQkJCWlmIChtYXRjaChpcHJfY21kLCBkZXZpY2UpKSB7CisJCQkJCWlwcl9jbWQtPmVoX2NvbXAgPSAmY29tcDsKKwkJCQkJd2FpdCsrOworCQkJCX0KKwkJCX0KKwkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoaHJycS0+bG9jaywgZmxhZ3MpOworCQl9CisKKwkJaWYgKHdhaXQpIHsKKwkJCXRpbWVvdXQgPSB3YWl0X2Zvcl9jb21wbGV0aW9uX3RpbWVvdXQoJmNvbXAsIHRpbWVvdXQpOworCisJCQlpZiAoIXRpbWVvdXQpIHsKKwkJCQl3YWl0ID0gMDsKKworCQkJCWZvcl9lYWNoX2hycnEoaHJycSwgaW9hX2NmZykgeworCQkJCQlzcGluX2xvY2tfaXJxc2F2ZShocnJxLT5sb2NrLCBmbGFncyk7CisJCQkJCWxpc3RfZm9yX2VhY2hfZW50cnkoaXByX2NtZCwgJmhycnEtPmhycnFfcGVuZGluZ19xLCBxdWV1ZSkgeworCQkJCQkJaWYgKG1hdGNoKGlwcl9jbWQsIGRldmljZSkpIHsKKwkJCQkJCQlpcHJfY21kLT5laF9jb21wID0gTlVMTDsKKwkJCQkJCQl3YWl0Kys7CisJCQkJCQl9CisJCQkJCX0KKwkJCQkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZShocnJxLT5sb2NrLCBmbGFncyk7CisJCQkJfQorCisJCQkJaWYgKHdhaXQpCisJCQkJCWRldl9lcnIoJmlvYV9jZmctPnBkZXYtPmRldiwgIlRpbWVkIG91dCB3YWl0aW5nIGZvciBhYm9ydGVkIGNvbW1hbmRzXG4iKTsKKwkJCQlMRUFWRTsKKwkJCQlyZXR1cm4gd2FpdCA/IEZBSUxFRCA6IFNVQ0NFU1M7CisJCQl9CisJCX0KKwl9IHdoaWxlICh3YWl0KTsKKworCUxFQVZFOworCXJldHVybiBTVUNDRVNTOworfQorCiBzdGF0aWMgaW50IGlwcl9laF9ob3N0X3Jlc2V0KHN0cnVjdCBzY3NpX2NtbmQgKmNtZCkKIHsKIAlzdHJ1Y3QgaXByX2lvYV9jZmcgKmlvYV9jZmc7CkBAIC01MDMwLDExICs1MTExLDE3IEBACiBzdGF0aWMgaW50IGlwcl9laF9kZXZfcmVzZXQoc3RydWN0IHNjc2lfY21uZCAqY21kKQogewogCWludCByYzsKKwlzdHJ1Y3QgaXByX2lvYV9jZmcgKmlvYV9jZmc7CisKKwlpb2FfY2ZnID0gKHN0cnVjdCBpcHJfaW9hX2NmZyAqKSBjbWQtPmRldmljZS0+aG9zdC0+aG9zdGRhdGE7CiAKIAlzcGluX2xvY2tfaXJxKGNtZC0+ZGV2aWNlLT5ob3N0LT5ob3N0X2xvY2spOwogCXJjID0gX19pcHJfZWhfZGV2X3Jlc2V0KGNtZCk7CiAJc3Bpbl91bmxvY2tfaXJxKGNtZC0+ZGV2aWNlLT5ob3N0LT5ob3N0X2xvY2spOwogCisJaWYgKHJjID09IFNVQ0NFU1MpCisJCXJjID0gaXByX3dhaXRfZm9yX29wcyhpb2FfY2ZnLCBjbWQtPmRldmljZSwgaXByX21hdGNoX2x1bik7CisKIAlyZXR1cm4gcmM7CiB9CiAKQEAgLTUyMzQsMTMgKzUzMjEsMTggQEAKIHsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCWludCByYzsKKwlzdHJ1Y3QgaXByX2lvYV9jZmcgKmlvYV9jZmc7CiAKIAlFTlRFUjsKIAorCWlvYV9jZmcgPSAoc3RydWN0IGlwcl9pb2FfY2ZnICopIHNjc2lfY21kLT5kZXZpY2UtPmhvc3QtPmhvc3RkYXRhOworCiAJc3Bpbl9sb2NrX2lycXNhdmUoc2NzaV9jbWQtPmRldmljZS0+aG9zdC0+aG9zdF9sb2NrLCBmbGFncyk7CiAJcmMgPSBpcHJfY2FuY2VsX29wKHNjc2lfY21kKTsKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKHNjc2lfY21kLT5kZXZpY2UtPmhvc3QtPmhvc3RfbG9jaywgZmxhZ3MpOwogCisJaWYgKHJjID09IFNVQ0NFU1MpCisJCXJjID0gaXByX3dhaXRfZm9yX29wcyhpb2FfY2ZnLCBzY3NpX2NtZC0+ZGV2aWNlLCBpcHJfbWF0Y2hfbHVuKTsKIAlMRUFWRTsKIAlyZXR1cm4gcmM7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvaXByLmggYi9kcml2ZXJzL3Njc2kvaXByLmgKaW5kZXggYjRmM2VlYy4uZWMwM2I0MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL2lwci5oCisrKyBiL2RyaXZlcnMvc2NzaS9pcHIuaApAQCAtMTYwNiw2ICsxNjA2LDcgQEAKIAkJc3RydWN0IHNjc2lfZGV2aWNlICpzZGV2OwogCX0gdTsKIAorCXN0cnVjdCBjb21wbGV0aW9uICplaF9jb21wOwogCXN0cnVjdCBpcHJfaHJyX3F1ZXVlICpocnJxOwogCXN0cnVjdCBpcHJfaW9hX2NmZyAqaW9hX2NmZzsKIH07CmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvc2NzaS5jIGIvZHJpdmVycy9zY3NpL3Njc2kuYwppbmRleCBlMDI4ODU0Li45YjM4Mjk5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvc2NzaS5jCisrKyBiL2RyaXZlcnMvc2NzaS9zY3NpLmMKQEAgLTk4Niw5ICs5ODYsOSBAQAogCQlyZXR1cm4gLUVOWElPOwogCWlmICghZ2V0X2RldmljZSgmc2Rldi0+c2Rldl9nZW5kZXYpKQogCQlyZXR1cm4gLUVOWElPOwotCS8qIFdlIGNhbiBmYWlsIHRoaXMgaWYgd2UncmUgZG9pbmcgU0NTSSBvcGVyYXRpb25zCisJLyogV2UgY2FuIGZhaWwgdHJ5X21vZHVsZV9nZXQgaWYgd2UncmUgZG9pbmcgU0NTSSBvcGVyYXRpb25zCiAJICogZnJvbSBtb2R1bGUgZXhpdCAobGlrZSBjYWNoZSBmbHVzaCkgKi8KLQl0cnlfbW9kdWxlX2dldChzZGV2LT5ob3N0LT5ob3N0dC0+bW9kdWxlKTsKKwlfX21vZHVsZV9nZXQoc2Rldi0+aG9zdC0+aG9zdHQtPm1vZHVsZSk7CiAKIAlyZXR1cm4gMDsKIH0KQEAgLTEwMDQsMTQgKzEwMDQsNyBAQAogICovCiB2b2lkIHNjc2lfZGV2aWNlX3B1dChzdHJ1Y3Qgc2NzaV9kZXZpY2UgKnNkZXYpCiB7Ci0jaWZkZWYgQ09ORklHX01PRFVMRV9VTkxPQUQKLQlzdHJ1Y3QgbW9kdWxlICptb2R1bGUgPSBzZGV2LT5ob3N0LT5ob3N0dC0+bW9kdWxlOwotCi0JLyogVGhlIG1vZHVsZSByZWZjb3VudCB3aWxsIGJlIHplcm8gaWYgc2NzaV9kZXZpY2VfZ2V0KCkKLQkgKiB3YXMgY2FsbGVkIGZyb20gYSBtb2R1bGUgcmVtb3ZhbCByb3V0aW5lICovCi0JaWYgKG1vZHVsZSAmJiBtb2R1bGVfcmVmY291bnQobW9kdWxlKSAhPSAwKQotCQltb2R1bGVfcHV0KG1vZHVsZSk7Ci0jZW5kaWYKKwltb2R1bGVfcHV0KHNkZXYtPmhvc3QtPmhvc3R0LT5tb2R1bGUpOwogCXB1dF9kZXZpY2UoJnNkZXYtPnNkZXZfZ2VuZGV2KTsKIH0KIEVYUE9SVF9TWU1CT0woc2NzaV9kZXZpY2VfcHV0KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9zY3NpX2RlYnVnLmMgYi9kcml2ZXJzL3Njc2kvc2NzaV9kZWJ1Zy5jCmluZGV4IDdiOGI1MWIuLjRhY2ExYjAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9zY3NpX2RlYnVnLmMKKysrIGIvZHJpdmVycy9zY3NpL3Njc2lfZGVidWcuYwpAQCAtMTYyMyw3ICsxNjIzLDcgQEAKIAlyZXFfb3Bjb2RlID0gY21kWzNdOwogCXJlcV9zYSA9IGdldF91bmFsaWduZWRfYmUxNihjbWQgKyA0KTsKIAlhbGxvY19sZW4gPSBnZXRfdW5hbGlnbmVkX2JlMzIoY21kICsgNik7Ci0JaWYgKGFsbG9jX2xlbiA8IDQgJiYgYWxsb2NfbGVuID4gMHhmZmZmKSB7CisJaWYgKGFsbG9jX2xlbiA8IDQgfHwgYWxsb2NfbGVuID4gMHhmZmZmKSB7CiAJCW1rX3NlbnNlX2ludmFsaWRfZmxkKHNjcCwgU0RFQl9JTl9DREIsIDYsIC0xKTsKIAkJcmV0dXJuIGNoZWNrX2NvbmRpdGlvbl9yZXN1bHQ7CiAJfQpAQCAtMTYzMSw3ICsxNjMxLDcgQEAKIAkJYV9sZW4gPSA4MTkyOwogCWVsc2UKIAkJYV9sZW4gPSBhbGxvY19sZW47Ci0JYXJyID0ga3phbGxvYygoYV9sZW4gPCAyNTYpID8gMzIwIDogYV9sZW4gKyA2NCwgR0ZQX0tFUk5FTCk7CisJYXJyID0ga3phbGxvYygoYV9sZW4gPCAyNTYpID8gMzIwIDogYV9sZW4gKyA2NCwgR0ZQX0FUT01JQyk7CiAJaWYgKE5VTEwgPT0gYXJyKSB7CiAJCW1rX3NlbnNlX2J1ZmZlcihzY3AsIElMTEVHQUxfUkVRVUVTVCwgSU5TVUZGX1JFU19BU0MsCiAJCQkJSU5TVUZGX1JFU19BU0NRKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9zY3NpX2xpYi5jIGIvZHJpdmVycy9zY3NpL3Njc2lfbGliLmMKaW5kZXggNmQ1YzBiOC4uMTdiYjU0MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL3Njc2lfbGliLmMKKysrIGIvZHJpdmVycy9zY3NpL3Njc2lfbGliLmMKQEAgLTExNDMsNyArMTE0MywxNyBAQAogCQlzdHJ1Y3Qgc2NzaV9kYXRhX2J1ZmZlciAqcHJvdF9zZGIgPSBjbWQtPnByb3Rfc2RiOwogCQlpbnQgaXZlY3MsIGNvdW50OwogCi0JCUJVR19PTihwcm90X3NkYiA9PSBOVUxMKTsKKwkJaWYgKHByb3Rfc2RiID09IE5VTEwpIHsKKwkJCS8qCisJCQkgKiBUaGlzIGNhbiBoYXBwZW4gaWYgc29tZW9uZSAoZS5nLiBtdWx0aXBhdGgpCisJCQkgKiBxdWV1ZXMgYSBjb21tYW5kIHRvIGEgZGV2aWNlIG9uIGFuIGFkYXB0ZXIKKwkJCSAqIHRoYXQgZG9lcyBub3Qgc3VwcG9ydCBESVguCisJCQkgKi8KKwkJCVdBUk5fT05fT05DRSgxKTsKKwkJCWVycm9yID0gQkxLUFJFUF9LSUxMOworCQkJZ290byBlcnJfZXhpdDsKKwkJfQorCiAJCWl2ZWNzID0gYmxrX3JxX2NvdW50X2ludGVncml0eV9zZyhycS0+cSwgcnEtPmJpbyk7CiAKIAkJaWYgKHNjc2lfYWxsb2Nfc2d0YWJsZShwcm90X3NkYiwgaXZlY3MsIGlzX21xKSkgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL3NkLmMgYi9kcml2ZXJzL3Njc2kvc2QuYwppbmRleCAzOTk1MTY5Li4wNWVhMGQ0IDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvc2QuYworKysgYi9kcml2ZXJzL3Njc2kvc2QuYwpAQCAtMjgwMCw5ICsyODAwLDExIEBACiAJICovCiAJc2Rfc2V0X2ZsdXNoX2ZsYWcoc2RrcCk7CiAKLQltYXhfeGZlciA9IG1pbl9ub3RfemVybyhxdWV1ZV9tYXhfaHdfc2VjdG9ycyhzZGtwLT5kaXNrLT5xdWV1ZSksCi0JCQkJc2RrcC0+bWF4X3hmZXJfYmxvY2tzKTsKKwltYXhfeGZlciA9IHNka3AtPm1heF94ZmVyX2Jsb2NrczsKIAltYXhfeGZlciA8PD0gaWxvZzIoc2RwLT5zZWN0b3Jfc2l6ZSkgLSA5OworCisJbWF4X3hmZXIgPSBtaW5fbm90X3plcm8ocXVldWVfbWF4X2h3X3NlY3RvcnMoc2RrcC0+ZGlzay0+cXVldWUpLAorCQkJCW1heF94ZmVyKTsKIAlibGtfcXVldWVfbWF4X2h3X3NlY3RvcnMoc2RrcC0+ZGlzay0+cXVldWUsIG1heF94ZmVyKTsKIAlzZXRfY2FwYWNpdHkoZGlzaywgc2RrcC0+Y2FwYWNpdHkpOwogCXNkX2NvbmZpZ193cml0ZV9zYW1lKHNka3ApOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zcGkvc3BpLWR3LW1pZC5jIGIvZHJpdmVycy9zcGkvc3BpLWR3LW1pZC5jCmluZGV4IDcyODEzMTYuLmE2N2QzN2MgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3BpL3NwaS1kdy1taWQuYworKysgYi9kcml2ZXJzL3NwaS9zcGktZHctbWlkLmMKQEAgLTI3MSw3ICsyNzEsNiBAQAogCWlvdW5tYXAoY2xrX3JlZyk7CiAKIAlkd3MtPm51bV9jcyA9IDE2OwotCWR3cy0+Zmlmb19sZW4gPSA0MDsJLyogRklGTyBoYXMgNDAgd29yZHMgYnVmZmVyICovCiAKICNpZmRlZiBDT05GSUdfU1BJX0RXX01JRF9ETUEKIAlkd3MtPmRtYV9wcml2ID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IG1pZF9kbWEpLCBHRlBfS0VSTkVMKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3BpL3NwaS1kdy5jIGIvZHJpdmVycy9zcGkvc3BpLWR3LmMKaW5kZXggZDBkNTU0Mi4uOGVkY2QxYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zcGkvc3BpLWR3LmMKKysrIGIvZHJpdmVycy9zcGkvc3BpLWR3LmMKQEAgLTYyMSwxMyArNjIxLDEzIEBACiAJaWYgKCFkd3MtPmZpZm9fbGVuKSB7CiAJCXUzMiBmaWZvOwogCi0JCWZvciAoZmlmbyA9IDI7IGZpZm8gPD0gMjU3OyBmaWZvKyspIHsKKwkJZm9yIChmaWZvID0gMjsgZmlmbyA8PSAyNTY7IGZpZm8rKykgewogCQkJZHdfd3JpdGV3KGR3cywgRFdfU1BJX1RYRkxUUiwgZmlmbyk7CiAJCQlpZiAoZmlmbyAhPSBkd19yZWFkdyhkd3MsIERXX1NQSV9UWEZMVFIpKQogCQkJCWJyZWFrOwogCQl9CiAKLQkJZHdzLT5maWZvX2xlbiA9IChmaWZvID09IDI1NykgPyAwIDogZmlmbzsKKwkJZHdzLT5maWZvX2xlbiA9IChmaWZvID09IDIpID8gMCA6IGZpZm8gLSAxOwogCQlkd193cml0ZXcoZHdzLCBEV19TUElfVFhGTFRSLCAwKTsKIAl9CiB9CkBAIC02NzMsNyArNjczLDcgQEAKIAlpZiAoZHdzLT5kbWFfb3BzICYmIGR3cy0+ZG1hX29wcy0+ZG1hX2luaXQpIHsKIAkJcmV0ID0gZHdzLT5kbWFfb3BzLT5kbWFfaW5pdChkd3MpOwogCQlpZiAocmV0KSB7Ci0JCQlkZXZfd2FybigmbWFzdGVyLT5kZXYsICJETUEgaW5pdCBmYWlsZWRcbiIpOworCQkJZGV2X3dhcm4oZGV2LCAiRE1BIGluaXQgZmFpbGVkXG4iKTsKIAkJCWR3cy0+ZG1hX2luaXRlZCA9IDA7CiAJCX0KIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3NwaS9zcGktZnNsLWRzcGkuYyBiL2RyaXZlcnMvc3BpL3NwaS1mc2wtZHNwaS5jCmluZGV4IDRjZGE5OTQuLjliODBkNTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3BpL3NwaS1mc2wtZHNwaS5jCisrKyBiL2RyaXZlcnMvc3BpL3NwaS1mc2wtZHNwaS5jCkBAIC0zNDIsOCArMzQyLDcgQEAKIAkvKiBPbmx5IGFsbG9jIG9uIGZpcnN0IHNldHVwICovCiAJY2hpcCA9IHNwaV9nZXRfY3RsZGF0YShzcGkpOwogCWlmIChjaGlwID09IE5VTEwpIHsKLQkJY2hpcCA9IGRldm1fa3phbGxvYygmc3BpLT5kZXYsIHNpemVvZihzdHJ1Y3QgY2hpcF9kYXRhKSwKLQkJCQkgICAgR0ZQX0tFUk5FTCk7CisJCWNoaXAgPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgY2hpcF9kYXRhKSwgR0ZQX0tFUk5FTCk7CiAJCWlmICghY2hpcCkKIAkJCXJldHVybiAtRU5PTUVNOwogCX0KQEAgLTM4Miw2ICszODEsMTYgQEAKIAlyZXR1cm4gZHNwaV9zZXR1cF90cmFuc2ZlcihzcGksIE5VTEwpOwogfQogCitzdGF0aWMgdm9pZCBkc3BpX2NsZWFudXAoc3RydWN0IHNwaV9kZXZpY2UgKnNwaSkKK3sKKwlzdHJ1Y3QgY2hpcF9kYXRhICpjaGlwID0gc3BpX2dldF9jdGxkYXRhKChzdHJ1Y3Qgc3BpX2RldmljZSAqKXNwaSk7CisKKwlkZXZfZGJnKCZzcGktPmRldiwgInNwaV9kZXZpY2UgJXUuJXUgY2xlYW51cFxuIiwKKwkJCXNwaS0+bWFzdGVyLT5idXNfbnVtLCBzcGktPmNoaXBfc2VsZWN0KTsKKworCWtmcmVlKGNoaXApOworfQorCiBzdGF0aWMgaXJxcmV0dXJuX3QgZHNwaV9pbnRlcnJ1cHQoaW50IGlycSwgdm9pZCAqZGV2X2lkKQogewogCXN0cnVjdCBmc2xfZHNwaSAqZHNwaSA9IChzdHJ1Y3QgZnNsX2RzcGkgKilkZXZfaWQ7CkBAIC00NjcsNiArNDc2LDcgQEAKIAlkc3BpLT5iaXRiYW5nLm1hc3Rlci0+c2V0dXAgPSBkc3BpX3NldHVwOwogCWRzcGktPmJpdGJhbmcubWFzdGVyLT5kZXYub2Zfbm9kZSA9IHBkZXYtPmRldi5vZl9ub2RlOwogCisJbWFzdGVyLT5jbGVhbnVwID0gZHNwaV9jbGVhbnVwOwogCW1hc3Rlci0+bW9kZV9iaXRzID0gU1BJX0NQT0wgfCBTUElfQ1BIQTsKIAltYXN0ZXItPmJpdHNfcGVyX3dvcmRfbWFzayA9IFNQSV9CUFdfTUFTSyg0KSB8IFNQSV9CUFdfTUFTSyg4KSB8CiAJCQkJCVNQSV9CUFdfTUFTSygxNik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3NwaS9zcGktaW14LmMgYi9kcml2ZXJzL3NwaS9zcGktaW14LmMKaW5kZXggOTYxYjk3ZC4uZmUxYjc2OSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zcGkvc3BpLWlteC5jCisrKyBiL2RyaXZlcnMvc3BpL3NwaS1pbXguYwpAQCAtODIzLDYgKzgyMywxMCBAQAogCXN0cnVjdCBkbWFfc2xhdmVfY29uZmlnIHNsYXZlX2NvbmZpZyA9IHt9OwogCWludCByZXQ7CiAKKwkvKiB1c2UgcGlvIG1vZGUgZm9yIGkubXg2ZGwgY2hpcCBUS1QyMzgyODUgKi8KKwlpZiAob2ZfbWFjaGluZV9pc19jb21wYXRpYmxlKCJmc2wsaW14NmRsIikpCisJCXJldHVybiAwOworCiAJLyogUHJlcGFyZSBmb3IgVFggRE1BOiAqLwogCW1hc3Rlci0+ZG1hX3R4ID0gZG1hX3JlcXVlc3Rfc2xhdmVfY2hhbm5lbChkZXYsICJ0eCIpOwogCWlmICghbWFzdGVyLT5kbWFfdHgpIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3BpL3NwaS1weGEyeHguYyBiL2RyaXZlcnMvc3BpL3NwaS1weGEyeHguYwppbmRleCAwNWM2MjNjLi4yMzgyMmU3IDEwMDY0NAotLS0gYS9kcml2ZXJzL3NwaS9zcGktcHhhMnh4LmMKKysrIGIvZHJpdmVycy9zcGkvc3BpLXB4YTJ4eC5jCkBAIC01NDYsOCArNTQ2LDggQEAKIAkJCWNzX2RlYXNzZXJ0KGRydl9kYXRhKTsKIAl9CiAKLQlzcGlfZmluYWxpemVfY3VycmVudF9tZXNzYWdlKGRydl9kYXRhLT5tYXN0ZXIpOwogCWRydl9kYXRhLT5jdXJfY2hpcCA9IE5VTEw7CisJc3BpX2ZpbmFsaXplX2N1cnJlbnRfbWVzc2FnZShkcnZfZGF0YS0+bWFzdGVyKTsKIH0KIAogc3RhdGljIHZvaWQgcmVzZXRfc2NjcjEoc3RydWN0IGRyaXZlcl9kYXRhICpkcnZfZGF0YSkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3BpL3NwaS1zaC1tc2lvZi5jIGIvZHJpdmVycy9zcGkvc3BpLXNoLW1zaW9mLmMKaW5kZXggOTZhNWZjMC4uM2FiN2EyMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zcGkvc3BpLXNoLW1zaW9mLmMKKysrIGIvZHJpdmVycy9zcGkvc3BpLXNoLW1zaW9mLmMKQEAgLTgyLDcgKzgyLDcgQEAKICNkZWZpbmUgTURSMV9TWU5DTURfTFIJIDB4MzAwMDAwMDAgLyogICBML1IgbW9kZSAqLwogI2RlZmluZSBNRFIxX1NZTkNBQ19TSElGVAkgMjUgLyogU3luYyBQb2xhcml0eSAoMSA9IEFjdGl2ZS1sb3cpICovCiAjZGVmaW5lIE1EUjFfQklUTFNCX1NISUZUCSAyNCAvKiBNU0IvTFNCIEZpcnN0ICgxID0gTFNCIGZpcnN0KSAqLwotI2RlZmluZSBNRFIxX0ZMRF9NQVNLCSAweDAwMDAwMGMwIC8qIEZyYW1lIFN5bmMgU2lnbmFsIEludGVydmFsICgwLTMpICovCisjZGVmaW5lIE1EUjFfRkxEX01BU0sJIDB4MDAwMDAwMGMgLyogRnJhbWUgU3luYyBTaWduYWwgSW50ZXJ2YWwgKDAtMykgKi8KICNkZWZpbmUgTURSMV9GTERfU0hJRlQJCSAgMgogI2RlZmluZSBNRFIxX1hYU1RQCSAweDAwMDAwMDAxIC8qIFRyYW5zbWlzc2lvbi9SZWNlcHRpb24gU3RvcCBvbiBGSUZPICovCiAvKiBUTURSMSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2x1c3RyZS9sdXN0cmUvbGxpdGUvdnZwX2lvLmMgYi9kcml2ZXJzL3N0YWdpbmcvbHVzdHJlL2x1c3RyZS9sbGl0ZS92dnBfaW8uYwppbmRleCA5MzBmNjAxLi42NWQ2MTBhIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvbHVzdHJlL2x1c3RyZS9sbGl0ZS92dnBfaW8uYworKysgYi9kcml2ZXJzL3N0YWdpbmcvbHVzdHJlL2x1c3RyZS9sbGl0ZS92dnBfaW8uYwpAQCAtNjMyLDcgKzYzMiw3IEBACiAJCXJldHVybiAwOwogCX0KIAotCWlmIChjZmlvLT5mYXVsdC5mdF9mbGFncyAmIFZNX0ZBVUxUX1NJR0JVUykgeworCWlmIChjZmlvLT5mYXVsdC5mdF9mbGFncyAmIChWTV9GQVVMVF9TSUdCVVMgfCBWTV9GQVVMVF9TSUdTRUdWKSkgewogCQlDREVCVUcoRF9QQUdFLCAiZ290IGFkZHIgJXAgLSBTSUdCVVNcbiIsIHZtZi0+dmlydHVhbF9hZGRyZXNzKTsKIAkJcmV0dXJuIC1FRkFVTFQ7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL21lZGlhL3RsZzIzMDAvS2NvbmZpZyBiL2RyaXZlcnMvc3RhZ2luZy9tZWRpYS90bGcyMzAwL0tjb25maWcKaW5kZXggODE3ODRjNi4uNzdkODc1MyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL21lZGlhL3RsZzIzMDAvS2NvbmZpZworKysgYi9kcml2ZXJzL3N0YWdpbmcvbWVkaWEvdGxnMjMwMC9LY29uZmlnCkBAIC0xLDYgKzEsNyBAQAogY29uZmlnIFZJREVPX1RMRzIzMDAKIAl0cmlzdGF0ZSAiVGVsZWdlbnQgVExHMjMwMCBVU0IgdmlkZW8gY2FwdHVyZSBzdXBwb3J0IChEZXByZWNhdGVkKSIKIAlkZXBlbmRzIG9uIFZJREVPX0RFViAmJiBJMkMgJiYgU05EICYmIERWQl9DT1JFCisJZGVwZW5kcyBvbiBNRURJQV9VU0JfU1VQUE9SVAogCXNlbGVjdCBWSURFT19UVU5FUgogCXNlbGVjdCBWSURFT19UVkVFUFJPTQogCWRlcGVuZHMgb24gUkNfQ09SRQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL252ZWMvbnZlYy5jIGIvZHJpdmVycy9zdGFnaW5nL252ZWMvbnZlYy5jCmluZGV4IDA5MzUzNWMuLjEyMGI3MGQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9udmVjL252ZWMuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvbnZlYy9udmVjLmMKQEAgLTg1LDIzICs4NSwyMCBAQAogc3RhdGljIGNvbnN0IHN0cnVjdCBtZmRfY2VsbCBudmVjX2RldmljZXNbXSA9IHsKIAl7CiAJCS5uYW1lID0gIm52ZWMta2JkIiwKLQkJLmlkID0gMSwKIAl9LAogCXsKIAkJLm5hbWUgPSAibnZlYy1tb3VzZSIsCi0JCS5pZCA9IDEsCisJfSwKKwl7CisJCS5uYW1lID0gIm52ZWMtcG93ZXIiLAorCQkuaWQgPSAwLAogCX0sCiAJewogCQkubmFtZSA9ICJudmVjLXBvd2VyIiwKIAkJLmlkID0gMSwKIAl9LAogCXsKLQkJLm5hbWUgPSAibnZlYy1wb3dlciIsCi0JCS5pZCA9IDIsCi0JfSwKLQl7CiAJCS5uYW1lID0gIm52ZWMtcGF6MDAiLAotCQkuaWQgPSAxLAogCX0sCiB9OwogCkBAIC04OTEsNyArODg4LDcgQEAKIAkJbnZlY19tc2dfZnJlZShudmVjLCBtc2cpOwogCX0KIAotCXJldCA9IG1mZF9hZGRfZGV2aWNlcyhudmVjLT5kZXYsIC0xLCBudmVjX2RldmljZXMsCisJcmV0ID0gbWZkX2FkZF9kZXZpY2VzKG52ZWMtPmRldiwgMCwgbnZlY19kZXZpY2VzLAogCQkJICAgICAgQVJSQVlfU0laRShudmVjX2RldmljZXMpLCBOVUxMLCAwLCBOVUxMKTsKIAlpZiAocmV0KQogCQlkZXZfZXJyKG52ZWMtPmRldiwgImVycm9yIGFkZGluZyBzdWJkZXZpY2VzXG4iKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2NvcmUvaHViLmMgYi9kcml2ZXJzL3VzYi9jb3JlL2h1Yi5jCmluZGV4IGFlYjUwYmIuLmVhZmZiMDIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL2NvcmUvaHViLmMKKysrIGIvZHJpdmVycy91c2IvY29yZS9odWIuYwpAQCAtMzQ1Miw4ICszNDUyLDYgQEAKIAlyZXR1cm4gc3RhdHVzOwogfQogCi0jaWZkZWYJQ09ORklHX1BNCi0KIGludCB1c2JfcmVtb3RlX3dha2V1cChzdHJ1Y3QgdXNiX2RldmljZSAqdWRldikKIHsKIAlpbnQJc3RhdHVzID0gMDsKQEAgLTM1MTIsMTYgKzM1MTAsNiBAQAogCXJldHVybiBjb25uZWN0X2NoYW5nZTsKIH0KIAotI2Vsc2UKLQotc3RhdGljIGludCBodWJfaGFuZGxlX3JlbW90ZV93YWtldXAoc3RydWN0IHVzYl9odWIgKmh1YiwgdW5zaWduZWQgaW50IHBvcnQsCi0JCXUxNiBwb3J0c3RhdHVzLCB1MTYgcG9ydGNoYW5nZSkKLXsKLQlyZXR1cm4gMDsKLX0KLQotI2VuZGlmCi0KIHN0YXRpYyBpbnQgY2hlY2tfcG9ydHNfY2hhbmdlZChzdHJ1Y3QgdXNiX2h1YiAqaHViKQogewogCWludCBwb3J0MTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2NvcmUvb3RnX3doaXRlbGlzdC5oIGIvZHJpdmVycy91c2IvY29yZS9vdGdfd2hpdGVsaXN0LmgKaW5kZXggZGUwYzljOS4uYTYzMTVhYiAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvY29yZS9vdGdfd2hpdGVsaXN0LmgKKysrIGIvZHJpdmVycy91c2IvY29yZS9vdGdfd2hpdGVsaXN0LmgKQEAgLTU1LDYgKzU1LDExIEBACiAJICAgICBsZTE2X3RvX2NwdShkZXYtPmRlc2NyaXB0b3IuaWRQcm9kdWN0KSA9PSAweGJhZGQpKQogCQlyZXR1cm4gMDsKIAorCS8qIE9URyBQRVQgZGV2aWNlIGlzIGFsd2F5cyB0YXJnZXRlZCAoc2VlIE9URyAyLjAgRUNOIDYuNC4yKSAqLworCWlmICgobGUxNl90b19jcHUoZGV2LT5kZXNjcmlwdG9yLmlkVmVuZG9yKSA9PSAweDFhMGEgJiYKKwkgICAgIGxlMTZfdG9fY3B1KGRldi0+ZGVzY3JpcHRvci5pZFByb2R1Y3QpID09IDB4MDIwMCkpCisJCXJldHVybiAxOworCiAJLyogTk9URTogY2FuJ3QgdXNlIHVzYl9tYXRjaF9pZCgpIHNpbmNlIGludGVyZmFjZSBjYWNoZXMKIAkgKiBhcmVuJ3Qgc2V0IHVwIHlldC4gdGhpcyBpcyBjdXQvcGFzdGUgZnJvbSB0aGF0IGNvZGUuCiAJICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9jb3JlL3F1aXJrcy5jIGIvZHJpdmVycy91c2IvY29yZS9xdWlya3MuYwppbmRleCAwZmZiNGVkLi40MWU1MTBhIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9jb3JlL3F1aXJrcy5jCisrKyBiL2RyaXZlcnMvdXNiL2NvcmUvcXVpcmtzLmMKQEAgLTE3OSw2ICsxNzksMTAgQEAKIAl7IFVTQl9ERVZJQ0UoMHgwYjA1LCAweDE3ZTApLCAuZHJpdmVyX2luZm8gPQogCQkJVVNCX1FVSVJLX0lHTk9SRV9SRU1PVEVfV0FLRVVQIH0sCiAKKwkvKiBQcm90b2NvbCBhbmQgT1RHIEVsZWN0cmljYWwgVGVzdCBEZXZpY2UgKi8KKwl7IFVTQl9ERVZJQ0UoMHgxYTBhLCAweDAyMDApLCAuZHJpdmVyX2luZm8gPQorCQkJVVNCX1FVSVJLX0xJTkVBUl9VRlJBTUVfSU5UUl9CSU5URVJWQUwgfSwKKwogCXsgfSAgLyogdGVybWluYXRpbmcgZW50cnkgbXVzdCBiZSBsYXN0ICovCiB9OwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9kd2MyL2NvcmVfaW50ci5jIGIvZHJpdmVycy91c2IvZHdjMi9jb3JlX2ludHIuYwppbmRleCBhZDQzYzViLi4wMmUzZTJkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9kd2MyL2NvcmVfaW50ci5jCisrKyBiL2RyaXZlcnMvdXNiL2R3YzIvY29yZV9pbnRyLmMKQEAgLTQ3NiwxMyArNDc2LDEzIEBACiAJdTMyIGdpbnRzdHM7CiAJaXJxcmV0dXJuX3QgcmV0dmFsID0gSVJRX05PTkU7CiAKKwlzcGluX2xvY2soJmhzb3RnLT5sb2NrKTsKKwogCWlmICghZHdjMl9pc19jb250cm9sbGVyX2FsaXZlKGhzb3RnKSkgewogCQlkZXZfd2Fybihoc290Zy0+ZGV2LCAiQ29udHJvbGxlciBpcyBkZWFkXG4iKTsKIAkJZ290byBvdXQ7CiAJfQogCi0Jc3Bpbl9sb2NrKCZoc290Zy0+bG9jayk7Ci0KIAlnaW50c3RzID0gZHdjMl9yZWFkX2NvbW1vbl9pbnRyKGhzb3RnKTsKIAlpZiAoZ2ludHN0cyAmIH5HSU5UU1RTX1BSVElOVCkKIAkJcmV0dmFsID0gSVJRX0hBTkRMRUQ7CkBAIC01MTUsOCArNTE1LDggQEAKIAkJfQogCX0KIAotCXNwaW5fdW5sb2NrKCZoc290Zy0+bG9jayk7CiBvdXQ6CisJc3Bpbl91bmxvY2soJmhzb3RnLT5sb2NrKTsKIAlyZXR1cm4gcmV0dmFsOwogfQogRVhQT1JUX1NZTUJPTF9HUEwoZHdjMl9oYW5kbGVfY29tbW9uX2ludHIpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvcGh5L3BoeS5jIGIvZHJpdmVycy91c2IvcGh5L3BoeS5jCmluZGV4IGNjZmRmYjIuLjJmOTczNWIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL3BoeS9waHkuYworKysgYi9kcml2ZXJzL3VzYi9waHkvcGh5LmMKQEAgLTM0LDcgKzM0LDcgQEAKIAkJcmV0dXJuIHBoeTsKIAl9CiAKLQlyZXR1cm4gRVJSX1BUUigtRVBST0JFX0RFRkVSKTsKKwlyZXR1cm4gRVJSX1BUUigtRU5PREVWKTsKIH0KIAogc3RhdGljIHN0cnVjdCB1c2JfcGh5ICpfX3VzYl9maW5kX3BoeV9kZXYoc3RydWN0IGRldmljZSAqZGV2LApkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2Ivc3RvcmFnZS91bnVzdWFsX2RldnMuaCBiL2RyaXZlcnMvdXNiL3N0b3JhZ2UvdW51c3VhbF9kZXZzLmgKaW5kZXggMTFjN2E5Ni4uZDY4NGI0YiAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2Ivc3RvcmFnZS91bnVzdWFsX2RldnMuaAorKysgYi9kcml2ZXJzL3VzYi9zdG9yYWdlL3VudXN1YWxfZGV2cy5oCkBAIC01MDcsNyArNTA3LDcgQEAKIFVOVVNVQUxfREVWKCAgMHgwNGU2LCAweDAwMGYsIDB4MDAwMCwgMHg5OTk5LAogCQkiU0NNIE1pY3Jvc3lzdGVtcyIsCiAJCSJlVVNCIFNDU0kgQWRhcHRlciAoQnVzIFBvd2VyZWQpIiwKLQkJVVNCX1NDX0RFVklDRSwgVVNCX1BSX0RFVklDRSwgdXNiX3N0b3JfZXVzY3NpX2luaXQsCisJCVVTQl9TQ19TQ1NJLCBVU0JfUFJfQlVMSywgdXNiX3N0b3JfZXVzY3NpX2luaXQsCiAJCVVTX0ZMX1NDTV9NVUxUX1RBUkcgKSwKIAogVU5VU1VBTF9ERVYoICAweDA0ZTYsIDB4MDEwMSwgMHgwMjAwLCAweDAyMDAsCkBAIC0xOTk1LDYgKzE5OTUsMTMgQEAKIAkJVVNCX1NDX0RFVklDRSwgVVNCX1BSX0RFVklDRSwgTlVMTCwKIAkJVVNfRkxfSUdOT1JFX1JFU0lEVUUgfCBVU19GTF9TQU5FX1NFTlNFICksCiAKKy8qIFJlcG9ydGVkIGJ5IERtaXRyeSBOZXpoZXZlbmtvIDxkaW9uQGRpb24ub3JnLnVhPiAqLworVU5VU1VBTF9ERVYoICAweDE1MmQsIDB4MjU2NiwgMHgwMTE0LCAweDAxMTQsCisJCSJKTWljcm9uIiwKKwkJIlVTQiB0byBBVEEvQVRBUEkgQnJpZGdlIiwKKwkJVVNCX1NDX0RFVklDRSwgVVNCX1BSX0RFVklDRSwgTlVMTCwKKwkJVVNfRkxfQlJPS0VOX0ZVQSApLAorCiAvKiBFbnRyZWdhIFRlY2hub2xvZ2llcyBVMS1TQzI1IChsYXRlciBYaXJjb20gUG9ydEdlYXIgUEdTQ1NJKQogICogYW5kIE1hYyBVU0IgRG9jayBVU0ItU0NTSSAqLwogVU5VU1VBTF9ERVYoICAweDE2NDUsIDB4MDAwNywgMHgwMTAwLCAweDAxMzMsCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9zdG9yYWdlL3VudXN1YWxfdWFzLmggYi9kcml2ZXJzL3VzYi9zdG9yYWdlL3VudXN1YWxfdWFzLmgKaW5kZXggNmRmNDM1Ny4uZGJjMDBlNSAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2Ivc3RvcmFnZS91bnVzdWFsX3Vhcy5oCisrKyBiL2RyaXZlcnMvdXNiL3N0b3JhZ2UvdW51c3VhbF91YXMuaApAQCAtMTQwLDMgKzE0MCwxMCBAQAogCQkiRXh0ZXJuYWwgSEREIiwKIAkJVVNCX1NDX0RFVklDRSwgVVNCX1BSX0RFVklDRSwgTlVMTCwKIAkJVVNfRkxfSUdOT1JFX1VBUyksCisKKy8qIFJlcG9ydGVkLWJ5OiBSaWNoYXJkIEhlbmRlcnNvbiA8cnRoQHJlZGhhdC5jb20+ICovCitVTlVTVUFMX0RFVigweDQ5NzEsIDB4ODAxNywgMHgwMDAwLCAweDk5OTksCisJCSJTaW1wbGVUZWNoIiwKKwkJIkV4dGVybmFsIEhERCIsCisJCVVTQl9TQ19ERVZJQ0UsIFVTQl9QUl9ERVZJQ0UsIE5VTEwsCisJCVVTX0ZMX05PX1JFUE9SVF9PUENPREVTKSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmhvc3QvbmV0LmMgYi9kcml2ZXJzL3Zob3N0L25ldC5jCmluZGV4IGQ0MTVkNjkuLjk0ODRkNTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmhvc3QvbmV0LmMKKysrIGIvZHJpdmVycy92aG9zdC9uZXQuYwpAQCAtNjUwLDggKzY1MCwxMCBAQAogCQkJYnJlYWs7CiAJCX0KIAkJLyogVE9ETzogU2hvdWxkIGNoZWNrIGFuZCBoYW5kbGUgY2hlY2tzdW0uICovCisKKwkJaGRyLm51bV9idWZmZXJzID0gY3B1X3RvX3Zob3N0MTYodnEsIGhlYWRjb3VudCk7CiAJCWlmIChsaWtlbHkobWVyZ2VhYmxlKSAmJgotCQkgICAgbWVtY3B5X3RvaW92ZWNlbmQobnZxLT5oZHIsICh1bnNpZ25lZCBjaGFyICopJmhlYWRjb3VudCwKKwkJICAgIG1lbWNweV90b2lvdmVjZW5kKG52cS0+aGRyLCAodm9pZCAqKSZoZHIubnVtX2J1ZmZlcnMsCiAJCQkJICAgICAgb2Zmc2V0b2YodHlwZW9mKGhkciksIG51bV9idWZmZXJzKSwKIAkJCQkgICAgICBzaXplb2YgaGRyLm51bV9idWZmZXJzKSkgewogCQkJdnFfZXJyKHZxLCAiRmFpbGVkIG51bV9idWZmZXJzIHdyaXRlIik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3dhdGNoZG9nL2NhZGVuY2Vfd2R0LmMgYi9kcml2ZXJzL3dhdGNoZG9nL2NhZGVuY2Vfd2R0LmMKaW5kZXggNTkyN2MwYS4uYmNmZDJhMiAxMDA2NDQKLS0tIGEvZHJpdmVycy93YXRjaGRvZy9jYWRlbmNlX3dkdC5jCisrKyBiL2RyaXZlcnMvd2F0Y2hkb2cvY2FkZW5jZV93ZHQuYwpAQCAtNTAzLDcgKzUwMyw2IEBACiAJLnNodXRkb3duCT0gY2Ruc193ZHRfc2h1dGRvd24sCiAJLmRyaXZlcgkJPSB7CiAJCS5uYW1lCT0gImNkbnMtd2R0IiwKLQkJLm93bmVyCT0gVEhJU19NT0RVTEUsCiAJCS5vZl9tYXRjaF90YWJsZSA9IGNkbnNfd2R0X29mX21hdGNoLAogCQkucG0JPSAmY2Ruc193ZHRfcG1fb3BzLAogCX0sCmRpZmYgLS1naXQgYS9kcml2ZXJzL3dhdGNoZG9nL2lteDJfd2R0LmMgYi9kcml2ZXJzL3dhdGNoZG9nL2lteDJfd2R0LmMKaW5kZXggZDZhZGQ1MS4uNTE0MmJiYSAxMDA2NDQKLS0tIGEvZHJpdmVycy93YXRjaGRvZy9pbXgyX3dkdC5jCisrKyBiL2RyaXZlcnMvd2F0Y2hkb2cvaW14Ml93ZHQuYwpAQCAtNTIsNiArNTIsOCBAQAogI2RlZmluZSBJTVgyX1dEVF9XUlNSCQkweDA0CQkvKiBSZXNldCBTdGF0dXMgUmVnaXN0ZXIgKi8KICNkZWZpbmUgSU1YMl9XRFRfV1JTUl9UT1VUCSgxIDw8IDEpCS8qIC0+IFJlc2V0IGR1ZSB0byBUaW1lb3V0ICovCiAKKyNkZWZpbmUgSU1YMl9XRFRfV01DUgkJMHgwOAkJLyogTWlzYyBSZWdpc3RlciAqLworCiAjZGVmaW5lIElNWDJfV0RUX01BWF9USU1FCTEyOAogI2RlZmluZSBJTVgyX1dEVF9ERUZBVUxUX1RJTUUJNjAJCS8qIGluIHNlY29uZHMgKi8KIApAQCAtMjc0LDYgKzI3NiwxMyBAQAogCiAJaW14Ml93ZHRfcGluZ19pZl9hY3RpdmUod2RvZyk7CiAKKwkvKgorCSAqIERpc2FibGUgdGhlIHdhdGNoZG9nIHBvd2VyIGRvd24gY291bnRlciBhdCBib290LiBPdGhlcndpc2UgdGhlIHBvd2VyCisJICogZG93biBjb3VudGVyIHdpbGwgcHVsbCBkb3duIHRoZSAjV0RPRyBpbnRlcnJ1cHQgbGluZSBmb3Igb25lIGNsb2NrCisJICogY3ljbGUuCisJICovCisJcmVnbWFwX3dyaXRlKHdkZXYtPnJlZ21hcCwgSU1YMl9XRFRfV01DUiwgMCk7CisKIAlyZXQgPSB3YXRjaGRvZ19yZWdpc3Rlcl9kZXZpY2Uod2RvZyk7CiAJaWYgKHJldCkgewogCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJjYW5ub3QgcmVnaXN0ZXIgd2F0Y2hkb2cgZGV2aWNlXG4iKTsKQEAgLTMyNywxOCArMzM2LDIxIEBACiB9CiAKICNpZmRlZiBDT05GSUdfUE1fU0xFRVAKLS8qIERpc2FibGUgd2F0Y2hkb2cgaWYgaXQgaXMgYWN0aXZlIGR1cmluZyBzdXNwZW5kICovCisvKiBEaXNhYmxlIHdhdGNoZG9nIGlmIGl0IGlzIGFjdGl2ZSBvciBub24tYWN0aXZlIGJ1dCBzdGlsbCBydW5uaW5nICovCiBzdGF0aWMgaW50IGlteDJfd2R0X3N1c3BlbmQoc3RydWN0IGRldmljZSAqZGV2KQogewogCXN0cnVjdCB3YXRjaGRvZ19kZXZpY2UgKndkb2cgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKIAlzdHJ1Y3QgaW14Ml93ZHRfZGV2aWNlICp3ZGV2ID0gd2F0Y2hkb2dfZ2V0X2RydmRhdGEod2RvZyk7CiAKLQlpbXgyX3dkdF9zZXRfdGltZW91dCh3ZG9nLCBJTVgyX1dEVF9NQVhfVElNRSk7Ci0JaW14Ml93ZHRfcGluZyh3ZG9nKTsKKwkvKiBUaGUgd2F0Y2hkb2cgSVAgYmxvY2sgaXMgcnVubmluZyAqLworCWlmIChpbXgyX3dkdF9pc19ydW5uaW5nKHdkZXYpKSB7CisJCWlteDJfd2R0X3NldF90aW1lb3V0KHdkb2csIElNWDJfV0RUX01BWF9USU1FKTsKKwkJaW14Ml93ZHRfcGluZyh3ZG9nKTsKIAotCS8qIFdhdGNoZG9nIGhhcyBiZWVuIHN0b3BwZWQgYnV0IElQIGJsb2NrIGlzIHN0aWxsIHJ1bm5pbmcgKi8KLQlpZiAoIXdhdGNoZG9nX2FjdGl2ZSh3ZG9nKSAmJiBpbXgyX3dkdF9pc19ydW5uaW5nKHdkZXYpKQotCQlkZWxfdGltZXJfc3luYygmd2Rldi0+dGltZXIpOworCQkvKiBUaGUgd2F0Y2hkb2cgaXMgbm90IGFjdGl2ZSAqLworCQlpZiAoIXdhdGNoZG9nX2FjdGl2ZSh3ZG9nKSkKKwkJCWRlbF90aW1lcl9zeW5jKCZ3ZGV2LT50aW1lcik7CisJfQogCiAJY2xrX2Rpc2FibGVfdW5wcmVwYXJlKHdkZXYtPmNsayk7CiAKQEAgLTM1NCwxNSArMzY2LDI1IEBACiAJY2xrX3ByZXBhcmVfZW5hYmxlKHdkZXYtPmNsayk7CiAKIAlpZiAod2F0Y2hkb2dfYWN0aXZlKHdkb2cpICYmICFpbXgyX3dkdF9pc19ydW5uaW5nKHdkZXYpKSB7Ci0JCS8qIFJlc3VtZXMgZnJvbSBkZWVwIHNsZWVwIHdlIG5lZWQgcmVzdGFydAotCQkgKiB0aGUgd2F0Y2hkb2cgYWdhaW4uCisJCS8qCisJCSAqIElmIHRoZSB3YXRjaGRvZyBpcyBzdGlsbCBhY3RpdmUgYW5kIHJlc3VtZXMKKwkJICogZnJvbSBkZWVwIHNsZWVwIHN0YXRlLCBuZWVkIHRvIHJlc3RhcnQgdGhlCisJCSAqIHdhdGNoZG9nIGFnYWluLgogCQkgKi8KIAkJaW14Ml93ZHRfc2V0dXAod2RvZyk7CiAJCWlteDJfd2R0X3NldF90aW1lb3V0KHdkb2csIHdkb2ctPnRpbWVvdXQpOwogCQlpbXgyX3dkdF9waW5nKHdkb2cpOwogCX0gZWxzZSBpZiAoaW14Ml93ZHRfaXNfcnVubmluZyh3ZGV2KSkgeworCQkvKiBSZXN1bWluZyBmcm9tIG5vbi1kZWVwIHNsZWVwIHN0YXRlLiAqLworCQlpbXgyX3dkdF9zZXRfdGltZW91dCh3ZG9nLCB3ZG9nLT50aW1lb3V0KTsKIAkJaW14Ml93ZHRfcGluZyh3ZG9nKTsKLQkJbW9kX3RpbWVyKCZ3ZGV2LT50aW1lciwgamlmZmllcyArIHdkb2ctPnRpbWVvdXQgKiBIWiAvIDIpOworCQkvKgorCQkgKiBCdXQgdGhlIHdhdGNoZG9nIGlzIG5vdCBhY3RpdmUsIHRoZW4gc3RhcnQKKwkJICogdGhlIHRpbWVyIGFnYWluLgorCQkgKi8KKwkJaWYgKCF3YXRjaGRvZ19hY3RpdmUod2RvZykpCisJCQltb2RfdGltZXIoJndkZXYtPnRpbWVyLAorCQkJCSAgamlmZmllcyArIHdkb2ctPnRpbWVvdXQgKiBIWiAvIDIpOwogCX0KIAogCXJldHVybiAwOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy93YXRjaGRvZy9tZXNvbl93ZHQuYyBiL2RyaXZlcnMvd2F0Y2hkb2cvbWVzb25fd2R0LmMKaW5kZXggZWY2YTI5OC4uMWY0MTU1ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy93YXRjaGRvZy9tZXNvbl93ZHQuYworKysgYi9kcml2ZXJzL3dhdGNoZG9nL21lc29uX3dkdC5jCkBAIC0yMTUsNyArMjE1LDYgQEAKIAkucmVtb3ZlCQk9IG1lc29uX3dkdF9yZW1vdmUsCiAJLnNodXRkb3duCT0gbWVzb25fd2R0X3NodXRkb3duLAogCS5kcml2ZXIJCT0gewotCQkub3duZXIJCT0gVEhJU19NT0RVTEUsCiAJCS5uYW1lCQk9IERSVl9OQU1FLAogCQkub2ZfbWF0Y2hfdGFibGUJPSBtZXNvbl93ZHRfZHRfaWRzLAogCX0sCmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi94ZW4tYWNwaS1tZW1ob3RwbHVnLmMgYi9kcml2ZXJzL3hlbi94ZW4tYWNwaS1tZW1ob3RwbHVnLmMKaW5kZXggMzRlNDBiNy4uNGZjODg2YyAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4veGVuLWFjcGktbWVtaG90cGx1Zy5jCisrKyBiL2RyaXZlcnMveGVuL3hlbi1hY3BpLW1lbWhvdHBsdWcuYwpAQCAtMTE3LDggKzExNyw4IEBACiAJbGlzdF9mb3JfZWFjaF9lbnRyeShpbmZvLCAmbWVtX2RldmljZS0+cmVzX2xpc3QsIGxpc3QpIHsKIAkJaWYgKChpbmZvLT5jYWNoaW5nID09IGFkZHJlc3M2NC5pbmZvLm1lbS5jYWNoaW5nKSAmJgogCQkgICAgKGluZm8tPndyaXRlX3Byb3RlY3QgPT0gYWRkcmVzczY0LmluZm8ubWVtLndyaXRlX3Byb3RlY3QpICYmCi0JCSAgICAoaW5mby0+c3RhcnRfYWRkciArIGluZm8tPmxlbmd0aCA9PSBhZGRyZXNzNjQubWluaW11bSkpIHsKLQkJCWluZm8tPmxlbmd0aCArPSBhZGRyZXNzNjQuYWRkcmVzc19sZW5ndGg7CisJCSAgICAoaW5mby0+c3RhcnRfYWRkciArIGluZm8tPmxlbmd0aCA9PSBhZGRyZXNzNjQuYWRkcmVzcy5taW5pbXVtKSkgeworCQkJaW5mby0+bGVuZ3RoICs9IGFkZHJlc3M2NC5hZGRyZXNzLmFkZHJlc3NfbGVuZ3RoOwogCQkJcmV0dXJuIEFFX09LOwogCQl9CiAJfQpAQCAtMTMwLDggKzEzMCw4IEBACiAJSU5JVF9MSVNUX0hFQUQoJm5ldy0+bGlzdCk7CiAJbmV3LT5jYWNoaW5nID0gYWRkcmVzczY0LmluZm8ubWVtLmNhY2hpbmc7CiAJbmV3LT53cml0ZV9wcm90ZWN0ID0gYWRkcmVzczY0LmluZm8ubWVtLndyaXRlX3Byb3RlY3Q7Ci0JbmV3LT5zdGFydF9hZGRyID0gYWRkcmVzczY0Lm1pbmltdW07Ci0JbmV3LT5sZW5ndGggPSBhZGRyZXNzNjQuYWRkcmVzc19sZW5ndGg7CisJbmV3LT5zdGFydF9hZGRyID0gYWRkcmVzczY0LmFkZHJlc3MubWluaW11bTsKKwluZXctPmxlbmd0aCA9IGFkZHJlc3M2NC5hZGRyZXNzLmFkZHJlc3NfbGVuZ3RoOwogCWxpc3RfYWRkX3RhaWwoJm5ldy0+bGlzdCwgJm1lbV9kZXZpY2UtPnJlc19saXN0KTsKIAogCXJldHVybiBBRV9PSzsKZGlmZiAtLWdpdCBhL2ZzL2Fpby5jIGIvZnMvYWlvLmMKaW5kZXggMWI3ODkzZS4uYzQyODg3MSAxMDA2NDQKLS0tIGEvZnMvYWlvLmMKKysrIGIvZnMvYWlvLmMKQEAgLTExNDAsNiArMTE0MCwxMyBAQAogCWxvbmcgcmV0ID0gMDsKIAlpbnQgY29weV9yZXQ7CiAKKwkvKgorCSAqIFRoZSBtdXRleCBjYW4gYmxvY2sgYW5kIHdha2UgdXMgdXAgYW5kIHRoYXQgd2lsbCBjYXVzZQorCSAqIHdhaXRfZXZlbnRfaW50ZXJydXB0aWJsZV9ocnRpbWVvdXQoKSB0byBzY2hlZHVsZSB3aXRob3V0IHNsZWVwaW5nCisJICogYW5kIHJlcGVhdC4gVGhpcyBzaG91bGQgYmUgcmFyZSBlbm91Z2ggdGhhdCBpdCBkb2Vzbid0IGNhdXNlCisJICogcGVmb3JtYW5jZSBpc3N1ZXMuIFNlZSB0aGUgY29tbWVudCBpbiByZWFkX2V2ZW50cygpIGZvciBtb3JlIGRldGFpbC4KKwkgKi8KKwlzY2hlZF9hbm5vdGF0ZV9zbGVlcCgpOwogCW11dGV4X2xvY2soJmN0eC0+cmluZ19sb2NrKTsKIAogCS8qIEFjY2VzcyB0byAtPnJpbmdfcGFnZXMgaGVyZSBpcyBwcm90ZWN0ZWQgYnkgY3R4LT5yaW5nX2xvY2suICovCmRpZmYgLS1naXQgYS9mcy9idHJmcy9jdHJlZS5oIGIvZnMvYnRyZnMvY3RyZWUuaAppbmRleCA3ZTYwNzQxLi4wYjE4MDcwIDEwMDY0NAotLS0gYS9mcy9idHJmcy9jdHJlZS5oCisrKyBiL2ZzL2J0cmZzL2N0cmVlLmgKQEAgLTExNzEsNiArMTE3MSw3IEBACiAJc3RydWN0IHBlcmNwdV9jb3VudGVyIHRvdGFsX2J5dGVzX3Bpbm5lZDsKIAogCXN0cnVjdCBsaXN0X2hlYWQgbGlzdDsKKwkvKiBQcm90ZWN0ZWQgYnkgdGhlIHNwaW5sb2NrICdsb2NrJy4gKi8KIAlzdHJ1Y3QgbGlzdF9oZWFkIHJvX2JnczsKIAogCXN0cnVjdCByd19zZW1hcGhvcmUgZ3JvdXBzX3NlbTsKZGlmZiAtLWdpdCBhL2ZzL2J0cmZzL2V4dGVudC10cmVlLmMgYi9mcy9idHJmcy9leHRlbnQtdHJlZS5jCmluZGV4IDE1MTE2NTguLmE2ODQwODYgMTAwNjQ0Ci0tLSBhL2ZzL2J0cmZzL2V4dGVudC10cmVlLmMKKysrIGIvZnMvYnRyZnMvZXh0ZW50LXRyZWUuYwpAQCAtOTQyMiw3ICs5NDIyLDYgQEAKIAkgKiBhcmUgc3RpbGwgb24gdGhlIGxpc3QgYWZ0ZXIgdGFraW5nIHRoZSBzZW1hcGhvcmUKIAkgKi8KIAlsaXN0X2RlbF9pbml0KCZibG9ja19ncm91cC0+bGlzdCk7Ci0JbGlzdF9kZWxfaW5pdCgmYmxvY2tfZ3JvdXAtPnJvX2xpc3QpOwogCWlmIChsaXN0X2VtcHR5KCZibG9ja19ncm91cC0+c3BhY2VfaW5mby0+YmxvY2tfZ3JvdXBzW2luZGV4XSkpIHsKIAkJa29iaiA9IGJsb2NrX2dyb3VwLT5zcGFjZV9pbmZvLT5ibG9ja19ncm91cF9rb2Jqc1tpbmRleF07CiAJCWJsb2NrX2dyb3VwLT5zcGFjZV9pbmZvLT5ibG9ja19ncm91cF9rb2Jqc1tpbmRleF0gPSBOVUxMOwpAQCAtOTQ2NCw2ICs5NDYzLDcgQEAKIAlidHJmc19yZW1vdmVfZnJlZV9zcGFjZV9jYWNoZShibG9ja19ncm91cCk7CiAKIAlzcGluX2xvY2soJmJsb2NrX2dyb3VwLT5zcGFjZV9pbmZvLT5sb2NrKTsKKwlsaXN0X2RlbF9pbml0KCZibG9ja19ncm91cC0+cm9fbGlzdCk7CiAJYmxvY2tfZ3JvdXAtPnNwYWNlX2luZm8tPnRvdGFsX2J5dGVzIC09IGJsb2NrX2dyb3VwLT5rZXkub2Zmc2V0OwogCWJsb2NrX2dyb3VwLT5zcGFjZV9pbmZvLT5ieXRlc19yZWFkb25seSAtPSBibG9ja19ncm91cC0+a2V5Lm9mZnNldDsKIAlibG9ja19ncm91cC0+c3BhY2VfaW5mby0+ZGlza190b3RhbCAtPSBibG9ja19ncm91cC0+a2V5Lm9mZnNldCAqIGZhY3RvcjsKZGlmZiAtLWdpdCBhL2ZzL2J0cmZzL2V4dGVudF9pby5jIGIvZnMvYnRyZnMvZXh0ZW50X2lvLmMKaW5kZXggNGViYWJkMi4uNzkwZGJhZSAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvZXh0ZW50X2lvLmMKKysrIGIvZnMvYnRyZnMvZXh0ZW50X2lvLmMKQEAgLTIxOTAsNyArMjE5MCw3IEBACiAKIAkJbmV4dCA9IG5leHRfc3RhdGUoc3RhdGUpOwogCi0JCWZhaWxyZWMgPSAoc3RydWN0IGlvX2ZhaWx1cmVfcmVjb3JkICopc3RhdGUtPnByaXZhdGU7CisJCWZhaWxyZWMgPSAoc3RydWN0IGlvX2ZhaWx1cmVfcmVjb3JkICopKHVuc2lnbmVkIGxvbmcpc3RhdGUtPnByaXZhdGU7CiAJCWZyZWVfZXh0ZW50X3N0YXRlKHN0YXRlKTsKIAkJa2ZyZWUoZmFpbHJlYyk7CiAKZGlmZiAtLWdpdCBhL2ZzL2J0cmZzL3NjcnViLmMgYi9mcy9idHJmcy9zY3J1Yi5jCmluZGV4IDllMTU2OWYuLmU0MjdjYjdlIDEwMDY0NAotLS0gYS9mcy9idHJmcy9zY3J1Yi5jCisrKyBiL2ZzL2J0cmZzL3NjcnViLmMKQEAgLTMwNTMsNyArMzA1Myw3IEBACiAKIAlwcGF0aCA9IGJ0cmZzX2FsbG9jX3BhdGgoKTsKIAlpZiAoIXBwYXRoKSB7Ci0JCWJ0cmZzX2ZyZWVfcGF0aChwcGF0aCk7CisJCWJ0cmZzX2ZyZWVfcGF0aChwYXRoKTsKIAkJcmV0dXJuIC1FTk9NRU07CiAJfQogCkBAIC0zMDY1LDYgKzMwNjUsOCBAQAogCXBhdGgtPnNlYXJjaF9jb21taXRfcm9vdCA9IDE7CiAJcGF0aC0+c2tpcF9sb2NraW5nID0gMTsKIAorCXBwYXRoLT5zZWFyY2hfY29tbWl0X3Jvb3QgPSAxOworCXBwYXRoLT5za2lwX2xvY2tpbmcgPSAxOwogCS8qCiAJICogdHJpZ2dlciB0aGUgcmVhZGFoZWFkIGZvciBleHRlbnQgdHJlZSBjc3VtIHRyZWUgYW5kIHdhaXQgZm9yCiAJICogY29tcGxldGlvbi4gRHVyaW5nIHJlYWRhaGVhZCwgdGhlIHNjcnViIGlzIG9mZmljaWFsbHkgcGF1c2VkCmRpZmYgLS1naXQgYS9mcy9idHJmcy9zdXBlci5jIGIvZnMvYnRyZnMvc3VwZXIuYwppbmRleCA2MGY3Y2JlLi42ZjQ5YjI4IDEwMDY0NAotLS0gYS9mcy9idHJmcy9zdXBlci5jCisrKyBiL2ZzL2J0cmZzL3N1cGVyLmMKQEAgLTEwMDAsMTAgKzEwMDAsMjAgQEAKIAkJCSAqLwogCQkJaWYgKGZzX2luZm8tPnBlbmRpbmdfY2hhbmdlcyA9PSAwKQogCQkJCXJldHVybiAwOworCQkJLyoKKwkJCSAqIEEgbm9uLWJsb2NraW5nIHRlc3QgaWYgdGhlIGZzIGlzIGZyb3plbi4gV2UgbXVzdCBub3QKKwkJCSAqIHN0YXJ0IGEgbmV3IHRyYW5zYWN0aW9uIGhlcmUgb3RoZXJ3aXNlIGEgZGVhZGxvY2sKKwkJCSAqIGhhcHBlbnMuIFRoZSBwZW5kaW5nIG9wZXJhdGlvbnMgYXJlIGRlbGF5ZWQgdG8gdGhlCisJCQkgKiBuZXh0IGNvbW1pdCBhZnRlciB0aGF3aW5nLgorCQkJICovCisJCQlpZiAoX19zYl9zdGFydF93cml0ZShzYiwgU0JfRlJFRVpFX1dSSVRFLCBmYWxzZSkpCisJCQkJX19zYl9lbmRfd3JpdGUoc2IsIFNCX0ZSRUVaRV9XUklURSk7CisJCQllbHNlCisJCQkJcmV0dXJuIDA7CiAJCQl0cmFucyA9IGJ0cmZzX3N0YXJ0X3RyYW5zYWN0aW9uKHJvb3QsIDApOwotCQl9IGVsc2UgewotCQkJcmV0dXJuIFBUUl9FUlIodHJhbnMpOwogCQl9CisJCWlmIChJU19FUlIodHJhbnMpKQorCQkJcmV0dXJuIFBUUl9FUlIodHJhbnMpOwogCX0KIAlyZXR1cm4gYnRyZnNfY29tbWl0X3RyYW5zYWN0aW9uKHRyYW5zLCByb290KTsKIH0KZGlmZiAtLWdpdCBhL2ZzL2J0cmZzL3RyYW5zYWN0aW9uLmMgYi9mcy9idHJmcy90cmFuc2FjdGlvbi5jCmluZGV4IGE2MDVkNGUuLmU4OGI1OWQgMTAwNjQ0Ci0tLSBhL2ZzL2J0cmZzL3RyYW5zYWN0aW9uLmMKKysrIGIvZnMvYnRyZnMvdHJhbnNhY3Rpb24uYwpAQCAtMjExOCw3ICsyMTE4LDcgQEAKIAl1bnNpZ25lZCBsb25nIHByZXY7CiAJdW5zaWduZWQgbG9uZyBiaXQ7CiAKLQlwcmV2ID0gY21weGNoZygmZnNfaW5mby0+cGVuZGluZ19jaGFuZ2VzLCAwLCAwKTsKKwlwcmV2ID0geGNoZygmZnNfaW5mby0+cGVuZGluZ19jaGFuZ2VzLCAwKTsKIAlpZiAoIXByZXYpCiAJCXJldHVybjsKIApkaWZmIC0tZ2l0IGEvZnMvYnRyZnMvdHJlZS1sb2cuYyBiL2ZzL2J0cmZzL3RyZWUtbG9nLmMKaW5kZXggOWEwMmRhMS4uMWE5NTg1ZCAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvdHJlZS1sb2cuYworKysgYi9mcy9idHJmcy90cmVlLWxvZy5jCkBAIC0yNTkxLDYgKzI1OTEsNyBAQAogCX0KIAogCWlmIChsb2dfcm9vdF90cmVlLT5sb2dfdHJhbnNpZF9jb21taXR0ZWQgPj0gcm9vdF9sb2dfY3R4LmxvZ190cmFuc2lkKSB7CisJCWJsa19maW5pc2hfcGx1ZygmcGx1Zyk7CiAJCW11dGV4X3VubG9jaygmbG9nX3Jvb3RfdHJlZS0+bG9nX211dGV4KTsKIAkJcmV0ID0gcm9vdF9sb2dfY3R4LmxvZ19yZXQ7CiAJCWdvdG8gb3V0OwpkaWZmIC0tZ2l0IGEvZnMvY2lmcy9jaWZzX2RlYnVnLmMgYi9mcy9jaWZzL2NpZnNfZGVidWcuYwppbmRleCA5YzU2ZWY3Li43ZmViY2YyIDEwMDY0NAotLS0gYS9mcy9jaWZzL2NpZnNfZGVidWcuYworKysgYi9mcy9jaWZzL2NpZnNfZGVidWcuYwpAQCAtNjA2LDkgKzYwNiwxMSBAQAogCQkqZmxhZ3MgPSBDSUZTU0VDX01VU1RfTlRMTVYyOwogCWVsc2UgaWYgKCgqZmxhZ3MgJiBDSUZTU0VDX01VU1RfTlRMTSkgPT0gQ0lGU1NFQ19NVVNUX05UTE0pCiAJCSpmbGFncyA9IENJRlNTRUNfTVVTVF9OVExNOwotCWVsc2UgaWYgKCgqZmxhZ3MgJiBDSUZTU0VDX01VU1RfTEFOTUFOKSA9PSBDSUZTU0VDX01VU1RfTEFOTUFOKQorCWVsc2UgaWYgKENJRlNTRUNfTVVTVF9MQU5NQU4gJiYKKwkJICgqZmxhZ3MgJiBDSUZTU0VDX01VU1RfTEFOTUFOKSA9PSBDSUZTU0VDX01VU1RfTEFOTUFOKQogCQkqZmxhZ3MgPSBDSUZTU0VDX01VU1RfTEFOTUFOOwotCWVsc2UgaWYgKCgqZmxhZ3MgJiBDSUZTU0VDX01VU1RfUExOVFhUKSA9PSBDSUZTU0VDX01VU1RfUExOVFhUKQorCWVsc2UgaWYgKENJRlNTRUNfTVVTVF9QTE5UWFQgJiYKKwkJICgqZmxhZ3MgJiBDSUZTU0VDX01VU1RfUExOVFhUKSA9PSBDSUZTU0VDX01VU1RfUExOVFhUKQogCQkqZmxhZ3MgPSBDSUZTU0VDX01VU1RfUExOVFhUOwogCiAJKmZsYWdzIHw9IHNpZ25mbGFnczsKZGlmZiAtLWdpdCBhL2ZzL2NpZnMvZmlsZS5jIGIvZnMvY2lmcy9maWxlLmMKaW5kZXggOTZiN2U5Yi4uNzRmMTI4NyAxMDA2NDQKLS0tIGEvZnMvY2lmcy9maWxlLmMKKysrIGIvZnMvY2lmcy9maWxlLmMKQEAgLTM2Niw2ICszNjYsNyBAQAogCXN0cnVjdCBjaWZzTG9ja0luZm8gKmxpLCAqdG1wOwogCXN0cnVjdCBjaWZzX2ZpZCBmaWQ7CiAJc3RydWN0IGNpZnNfcGVuZGluZ19vcGVuIG9wZW47CisJYm9vbCBvcGxvY2tfYnJlYWtfY2FuY2VsbGVkOwogCiAJc3Bpbl9sb2NrKCZjaWZzX2ZpbGVfbGlzdF9sb2NrKTsKIAlpZiAoLS1jaWZzX2ZpbGUtPmNvdW50ID4gMCkgewpAQCAtMzk3LDcgKzM5OCw3IEBACiAJfQogCXNwaW5fdW5sb2NrKCZjaWZzX2ZpbGVfbGlzdF9sb2NrKTsKIAotCWNhbmNlbF93b3JrX3N5bmMoJmNpZnNfZmlsZS0+b3Bsb2NrX2JyZWFrKTsKKwlvcGxvY2tfYnJlYWtfY2FuY2VsbGVkID0gY2FuY2VsX3dvcmtfc3luYygmY2lmc19maWxlLT5vcGxvY2tfYnJlYWspOwogCiAJaWYgKCF0Y29uLT5uZWVkX3JlY29ubmVjdCAmJiAhY2lmc19maWxlLT5pbnZhbGlkSGFuZGxlKSB7CiAJCXN0cnVjdCBUQ1BfU2VydmVyX0luZm8gKnNlcnZlciA9IHRjb24tPnNlcy0+c2VydmVyOwpAQCAtNDA5LDYgKzQxMCw5IEBACiAJCV9mcmVlX3hpZCh4aWQpOwogCX0KIAorCWlmIChvcGxvY2tfYnJlYWtfY2FuY2VsbGVkKQorCQljaWZzX2RvbmVfb3Bsb2NrX2JyZWFrKGNpZnNpKTsKKwogCWNpZnNfZGVsX3BlbmRpbmdfb3Blbigmb3Blbik7CiAKIAkvKgpkaWZmIC0tZ2l0IGEvZnMvY2lmcy9pb2N0bC5jIGIvZnMvY2lmcy9pb2N0bC5jCmluZGV4IDQ1Y2I1OWIuLjhiNzg5OGIgMTAwNjQ0Ci0tLSBhL2ZzL2NpZnMvaW9jdGwuYworKysgYi9mcy9jaWZzL2lvY3RsLmMKQEAgLTg2LDIxICs4NiwxNiBAQAogCX0KIAogCXNyY19pbm9kZSA9IGZpbGVfaW5vZGUoc3JjX2ZpbGUuZmlsZSk7CisJcmMgPSAtRUlOVkFMOworCWlmIChTX0lTRElSKHNyY19pbm9kZS0+aV9tb2RlKSkKKwkJZ290byBvdXRfZnB1dDsKIAogCS8qCiAJICogTm90ZTogY2lmcyBjYXNlIGlzIGVhc2llciB0aGFuIGJ0cmZzIHNpbmNlIHNlcnZlciByZXNwb25zaWJsZSBmb3IKIAkgKiBjaGVja3MgZm9yIHByb3BlciBvcGVuIG1vZGVzIGFuZCBmaWxlIHR5cGUgYW5kIGlmIGl0IHdhbnRzCiAJICogc2VydmVyIGNvdWxkIGV2ZW4gc3VwcG9ydCBjb3B5IG9mIHJhbmdlIHdoZXJlIHNvdXJjZSA9IHRhcmdldAogCSAqLwotCi0JLyogc28gd2UgZG8gbm90IGRlYWRsb2NrIHJhY2luZyB0d28gaW9jdGxzIG9uIHNhbWUgZmlsZXMgKi8KLQlpZiAodGFyZ2V0X2lub2RlIDwgc3JjX2lub2RlKSB7Ci0JCW11dGV4X2xvY2tfbmVzdGVkKCZ0YXJnZXRfaW5vZGUtPmlfbXV0ZXgsIElfTVVURVhfUEFSRU5UKTsKLQkJbXV0ZXhfbG9ja19uZXN0ZWQoJnNyY19pbm9kZS0+aV9tdXRleCwgSV9NVVRFWF9DSElMRCk7Ci0JfSBlbHNlIHsKLQkJbXV0ZXhfbG9ja19uZXN0ZWQoJnNyY19pbm9kZS0+aV9tdXRleCwgSV9NVVRFWF9QQVJFTlQpOwotCQltdXRleF9sb2NrX25lc3RlZCgmdGFyZ2V0X2lub2RlLT5pX211dGV4LCBJX01VVEVYX0NISUxEKTsKLQl9CisJbG9ja190d29fbm9uZGlyZWN0b3JpZXModGFyZ2V0X2lub2RlLCBzcmNfaW5vZGUpOwogCiAJLyogZGV0ZXJtaW5lIHJhbmdlIHRvIGNsb25lICovCiAJcmMgPSAtRUlOVkFMOwpAQCAtMTI0LDEzICsxMTksNyBAQAogb3V0X3VubG9jazoKIAkvKiBhbHRob3VnaCB1bmxvY2tpbmcgaW4gdGhlIHJldmVyc2Ugb3JkZXIgZnJvbSBsb2NraW5nIGlzIG5vdAogCSAgIHN0cmljdGx5IG5lY2Vzc2FyeSBoZXJlIGl0IGlzIGEgbGl0dGxlIGNsZWFuZXIgdG8gYmUgY29uc2lzdGVudCAqLwotCWlmICh0YXJnZXRfaW5vZGUgPCBzcmNfaW5vZGUpIHsKLQkJbXV0ZXhfdW5sb2NrKCZzcmNfaW5vZGUtPmlfbXV0ZXgpOwotCQltdXRleF91bmxvY2soJnRhcmdldF9pbm9kZS0+aV9tdXRleCk7Ci0JfSBlbHNlIHsKLQkJbXV0ZXhfdW5sb2NrKCZ0YXJnZXRfaW5vZGUtPmlfbXV0ZXgpOwotCQltdXRleF91bmxvY2soJnNyY19pbm9kZS0+aV9tdXRleCk7Ci0JfQorCXVubG9ja190d29fbm9uZGlyZWN0b3JpZXMoc3JjX2lub2RlLCB0YXJnZXRfaW5vZGUpOwogb3V0X2ZwdXQ6CiAJZmRwdXQoc3JjX2ZpbGUpOwogb3V0X2Ryb3Bfd3JpdGU6CmRpZmYgLS1naXQgYS9mcy9jaWZzL3NtYmVuY3J5cHQuYyBiL2ZzL2NpZnMvc21iZW5jcnlwdC5jCmluZGV4IDZjMTU2NjMuLmE0MjMyZWMgMTAwNjQ0Ci0tLSBhL2ZzL2NpZnMvc21iZW5jcnlwdC5jCisrKyBiL2ZzL2NpZnMvc21iZW5jcnlwdC5jCkBAIC0yMjEsNyArMjIxLDcgQEAKIAl9CiAKIAlyYyA9IG1kZm91cihwMTYsICh1bnNpZ25lZCBjaGFyICopIHdwd2QsIGxlbiAqIHNpemVvZihfX2xlMTYpKTsKLQltZW1zZXQod3B3ZCwgMCwgMTI5ICogc2l6ZW9mKF9fbGUxNikpOworCW1lbXplcm9fZXhwbGljaXQod3B3ZCwgc2l6ZW9mKHdwd2QpKTsKIAogCXJldHVybiByYzsKIH0KZGlmZiAtLWdpdCBhL2ZzL2dmczIvcXVvdGEuYyBiL2ZzL2dmczIvcXVvdGEuYwppbmRleCBjOGIxNDhiLi4zZTE5M2NiIDEwMDY0NAotLS0gYS9mcy9nZnMyL3F1b3RhLmMKKysrIGIvZnMvZ2ZzMi9xdW90YS5jCkBAIC02NjcsNyArNjY3LDcgQEAKIAogc3RhdGljIGludCBnZnMyX2FkanVzdF9xdW90YShzdHJ1Y3QgZ2ZzMl9pbm9kZSAqaXAsIGxvZmZfdCBsb2MsCiAJCQkgICAgIHM2NCBjaGFuZ2UsIHN0cnVjdCBnZnMyX3F1b3RhX2RhdGEgKnFkLAotCQkJICAgICBzdHJ1Y3QgZnNfZGlza19xdW90YSAqZmRxKQorCQkJICAgICBzdHJ1Y3QgcWNfZHFibGsgKmZkcSkKIHsKIAlzdHJ1Y3QgaW5vZGUgKmlub2RlID0gJmlwLT5pX2lub2RlOwogCXN0cnVjdCBnZnMyX3NiZCAqc2RwID0gR0ZTMl9TQihpbm9kZSk7CkBAIC02OTcsMTYgKzY5NywxNiBAQAogCWJlNjRfYWRkX2NwdSgmcS5xdV92YWx1ZSwgY2hhbmdlKTsKIAlxZC0+cWRfcWIucWJfdmFsdWUgPSBxLnF1X3ZhbHVlOwogCWlmIChmZHEpIHsKLQkJaWYgKGZkcS0+ZF9maWVsZG1hc2sgJiBGU19EUV9CU09GVCkgewotCQkJcS5xdV93YXJuID0gY3B1X3RvX2JlNjQoZmRxLT5kX2Jsa19zb2Z0bGltaXQgPj4gc2RwLT5zZF9mc2IyYmJfc2hpZnQpOworCQlpZiAoZmRxLT5kX2ZpZWxkbWFzayAmIFFDX1NQQ19TT0ZUKSB7CisJCQlxLnF1X3dhcm4gPSBjcHVfdG9fYmU2NChmZHEtPmRfc3BjX3NvZnRsaW1pdCA+PiBzZHAtPnNkX3NiLnNiX2JzaXplX3NoaWZ0KTsKIAkJCXFkLT5xZF9xYi5xYl93YXJuID0gcS5xdV93YXJuOwogCQl9Ci0JCWlmIChmZHEtPmRfZmllbGRtYXNrICYgRlNfRFFfQkhBUkQpIHsKLQkJCXEucXVfbGltaXQgPSBjcHVfdG9fYmU2NChmZHEtPmRfYmxrX2hhcmRsaW1pdCA+PiBzZHAtPnNkX2ZzYjJiYl9zaGlmdCk7CisJCWlmIChmZHEtPmRfZmllbGRtYXNrICYgUUNfU1BDX0hBUkQpIHsKKwkJCXEucXVfbGltaXQgPSBjcHVfdG9fYmU2NChmZHEtPmRfc3BjX2hhcmRsaW1pdCA+PiBzZHAtPnNkX3NiLnNiX2JzaXplX3NoaWZ0KTsKIAkJCXFkLT5xZF9xYi5xYl9saW1pdCA9IHEucXVfbGltaXQ7CiAJCX0KLQkJaWYgKGZkcS0+ZF9maWVsZG1hc2sgJiBGU19EUV9CQ09VTlQpIHsKLQkJCXEucXVfdmFsdWUgPSBjcHVfdG9fYmU2NChmZHEtPmRfYmNvdW50ID4+IHNkcC0+c2RfZnNiMmJiX3NoaWZ0KTsKKwkJaWYgKGZkcS0+ZF9maWVsZG1hc2sgJiBRQ19TUEFDRSkgeworCQkJcS5xdV92YWx1ZSA9IGNwdV90b19iZTY0KGZkcS0+ZF9zcGFjZSA+PiBzZHAtPnNkX3NiLnNiX2JzaXplX3NoaWZ0KTsKIAkJCXFkLT5xZF9xYi5xYl92YWx1ZSA9IHEucXVfdmFsdWU7CiAJCX0KIAl9CkBAIC0xNDk3LDcgKzE0OTcsNyBAQAogfQogCiBzdGF0aWMgaW50IGdmczJfZ2V0X2RxYmxrKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIHN0cnVjdCBrcWlkIHFpZCwKLQkJCSAgc3RydWN0IGZzX2Rpc2tfcXVvdGEgKmZkcSkKKwkJCSAgc3RydWN0IHFjX2RxYmxrICpmZHEpCiB7CiAJc3RydWN0IGdmczJfc2JkICpzZHAgPSBzYi0+c19mc19pbmZvOwogCXN0cnVjdCBnZnMyX3F1b3RhX2x2YiAqcWx2YjsKQEAgLTE1MDUsNyArMTUwNSw3IEBACiAJc3RydWN0IGdmczJfaG9sZGVyIHFfZ2g7CiAJaW50IGVycm9yOwogCi0JbWVtc2V0KGZkcSwgMCwgc2l6ZW9mKHN0cnVjdCBmc19kaXNrX3F1b3RhKSk7CisJbWVtc2V0KGZkcSwgMCwgc2l6ZW9mKCpmZHEpKTsKIAogCWlmIChzZHAtPnNkX2FyZ3MuYXJfcXVvdGEgPT0gR0ZTMl9RVU9UQV9PRkYpCiAJCXJldHVybiAtRVNSQ0g7IC8qIENyYXp5IFhGUyBlcnJvciBjb2RlICovCkBAIC0xNTIyLDEyICsxNTIyLDkgQEAKIAkJZ290byBvdXQ7CiAKIAlxbHZiID0gKHN0cnVjdCBnZnMyX3F1b3RhX2x2YiAqKXFkLT5xZF9nbC0+Z2xfbGtzYi5zYl9sdmJwdHI7Ci0JZmRxLT5kX3ZlcnNpb24gPSBGU19EUVVPVF9WRVJTSU9OOwotCWZkcS0+ZF9mbGFncyA9IChxaWQudHlwZSA9PSBVU1JRVU9UQSkgPyBGU19VU0VSX1FVT1RBIDogRlNfR1JPVVBfUVVPVEE7Ci0JZmRxLT5kX2lkID0gZnJvbV9rcWlkX211bmdlZChjdXJyZW50X3VzZXJfbnMoKSwgcWlkKTsKLQlmZHEtPmRfYmxrX2hhcmRsaW1pdCA9IGJlNjRfdG9fY3B1KHFsdmItPnFiX2xpbWl0KSA8PCBzZHAtPnNkX2ZzYjJiYl9zaGlmdDsKLQlmZHEtPmRfYmxrX3NvZnRsaW1pdCA9IGJlNjRfdG9fY3B1KHFsdmItPnFiX3dhcm4pIDw8IHNkcC0+c2RfZnNiMmJiX3NoaWZ0OwotCWZkcS0+ZF9iY291bnQgPSBiZTY0X3RvX2NwdShxbHZiLT5xYl92YWx1ZSkgPDwgc2RwLT5zZF9mc2IyYmJfc2hpZnQ7CisJZmRxLT5kX3NwY19oYXJkbGltaXQgPSBiZTY0X3RvX2NwdShxbHZiLT5xYl9saW1pdCkgPDwgc2RwLT5zZF9zYi5zYl9ic2l6ZV9zaGlmdDsKKwlmZHEtPmRfc3BjX3NvZnRsaW1pdCA9IGJlNjRfdG9fY3B1KHFsdmItPnFiX3dhcm4pIDw8IHNkcC0+c2Rfc2Iuc2JfYnNpemVfc2hpZnQ7CisJZmRxLT5kX3NwYWNlID0gYmU2NF90b19jcHUocWx2Yi0+cWJfdmFsdWUpIDw8IHNkcC0+c2Rfc2Iuc2JfYnNpemVfc2hpZnQ7CiAKIAlnZnMyX2dsb2NrX2RxX3VuaW5pdCgmcV9naCk7CiBvdXQ6CkBAIC0xNTM2LDEwICsxNTMzLDEwIEBACiB9CiAKIC8qIEdGUzIgb25seSBzdXBwb3J0cyBhIHN1YnNldCBvZiB0aGUgWEZTIGZpZWxkcyAqLwotI2RlZmluZSBHRlMyX0ZJRUxETUFTSyAoRlNfRFFfQlNPRlR8RlNfRFFfQkhBUkR8RlNfRFFfQkNPVU5UKQorI2RlZmluZSBHRlMyX0ZJRUxETUFTSyAoUUNfU1BDX1NPRlR8UUNfU1BDX0hBUkR8UUNfU1BBQ0UpCiAKIHN0YXRpYyBpbnQgZ2ZzMl9zZXRfZHFibGsoc3RydWN0IHN1cGVyX2Jsb2NrICpzYiwgc3RydWN0IGtxaWQgcWlkLAotCQkJICBzdHJ1Y3QgZnNfZGlza19xdW90YSAqZmRxKQorCQkJICBzdHJ1Y3QgcWNfZHFibGsgKmZkcSkKIHsKIAlzdHJ1Y3QgZ2ZzMl9zYmQgKnNkcCA9IHNiLT5zX2ZzX2luZm87CiAJc3RydWN0IGdmczJfaW5vZGUgKmlwID0gR0ZTMl9JKHNkcC0+c2RfcXVvdGFfaW5vZGUpOwpAQCAtMTU4MywxNyArMTU4MCwxNyBAQAogCQlnb3RvIG91dF9pOwogCiAJLyogSWYgbm90aGluZyBoYXMgY2hhbmdlZCwgdGhpcyBpcyBhIG5vLW9wICovCi0JaWYgKChmZHEtPmRfZmllbGRtYXNrICYgRlNfRFFfQlNPRlQpICYmCi0JICAgICgoZmRxLT5kX2Jsa19zb2Z0bGltaXQgPj4gc2RwLT5zZF9mc2IyYmJfc2hpZnQpID09IGJlNjRfdG9fY3B1KHFkLT5xZF9xYi5xYl93YXJuKSkpCi0JCWZkcS0+ZF9maWVsZG1hc2sgXj0gRlNfRFFfQlNPRlQ7CisJaWYgKChmZHEtPmRfZmllbGRtYXNrICYgUUNfU1BDX1NPRlQpICYmCisJICAgICgoZmRxLT5kX3NwY19zb2Z0bGltaXQgPj4gc2RwLT5zZF9zYi5zYl9ic2l6ZV9zaGlmdCkgPT0gYmU2NF90b19jcHUocWQtPnFkX3FiLnFiX3dhcm4pKSkKKwkJZmRxLT5kX2ZpZWxkbWFzayBePSBRQ19TUENfU09GVDsKIAotCWlmICgoZmRxLT5kX2ZpZWxkbWFzayAmIEZTX0RRX0JIQVJEKSAmJgotCSAgICAoKGZkcS0+ZF9ibGtfaGFyZGxpbWl0ID4+IHNkcC0+c2RfZnNiMmJiX3NoaWZ0KSA9PSBiZTY0X3RvX2NwdShxZC0+cWRfcWIucWJfbGltaXQpKSkKLQkJZmRxLT5kX2ZpZWxkbWFzayBePSBGU19EUV9CSEFSRDsKKwlpZiAoKGZkcS0+ZF9maWVsZG1hc2sgJiBRQ19TUENfSEFSRCkgJiYKKwkgICAgKChmZHEtPmRfc3BjX2hhcmRsaW1pdCA+PiBzZHAtPnNkX3NiLnNiX2JzaXplX3NoaWZ0KSA9PSBiZTY0X3RvX2NwdShxZC0+cWRfcWIucWJfbGltaXQpKSkKKwkJZmRxLT5kX2ZpZWxkbWFzayBePSBRQ19TUENfSEFSRDsKIAotCWlmICgoZmRxLT5kX2ZpZWxkbWFzayAmIEZTX0RRX0JDT1VOVCkgJiYKLQkgICAgKChmZHEtPmRfYmNvdW50ID4+IHNkcC0+c2RfZnNiMmJiX3NoaWZ0KSA9PSBiZTY0X3RvX2NwdShxZC0+cWRfcWIucWJfdmFsdWUpKSkKLQkJZmRxLT5kX2ZpZWxkbWFzayBePSBGU19EUV9CQ09VTlQ7CisJaWYgKChmZHEtPmRfZmllbGRtYXNrICYgUUNfU1BBQ0UpICYmCisJICAgICgoZmRxLT5kX3NwYWNlID4+IHNkcC0+c2Rfc2Iuc2JfYnNpemVfc2hpZnQpID09IGJlNjRfdG9fY3B1KHFkLT5xZF9xYi5xYl92YWx1ZSkpKQorCQlmZHEtPmRfZmllbGRtYXNrIF49IFFDX1NQQUNFOwogCiAJaWYgKGZkcS0+ZF9maWVsZG1hc2sgPT0gMCkKIAkJZ290byBvdXRfaTsKZGlmZiAtLWdpdCBhL2ZzL25mcy9kaXJlY3QuYyBiL2ZzL25mcy9kaXJlY3QuYwppbmRleCAxMGJmMDcyLi4yOTQ2OTJmIDEwMDY0NAotLS0gYS9mcy9uZnMvZGlyZWN0LmMKKysrIGIvZnMvbmZzL2RpcmVjdC5jCkBAIC0yMTIsNiArMjEyLDEyIEBACiAgKi8KIHNzaXplX3QgbmZzX2RpcmVjdF9JTyhpbnQgcncsIHN0cnVjdCBraW9jYiAqaW9jYiwgc3RydWN0IGlvdl9pdGVyICppdGVyLCBsb2ZmX3QgcG9zKQogeworCXN0cnVjdCBpbm9kZSAqaW5vZGUgPSBpb2NiLT5raV9maWxwLT5mX21hcHBpbmctPmhvc3Q7CisKKwkvKiB3ZSBvbmx5IHN1cHBvcnQgc3dhcCBmaWxlIGNhbGxpbmcgbmZzX2RpcmVjdF9JTyAqLworCWlmICghSVNfU1dBUEZJTEUoaW5vZGUpKQorCQlyZXR1cm4gMDsKKwogI2lmbmRlZiBDT05GSUdfTkZTX1NXQVAKIAlkcHJpbnRrKCJORlM6IG5mc19kaXJlY3RfSU8gKCVwRCkgb2ZmL25vKCVMZC8lbHUpIEVJTlZBTFxuIiwKIAkJCWlvY2ItPmtpX2ZpbHAsIChsb25nIGxvbmcpIHBvcywgaXRlci0+bnJfc2Vncyk7CmRpZmYgLS1naXQgYS9mcy9uZnMvaW5vZGUuYyBiL2ZzL25mcy9pbm9kZS5jCmluZGV4IDRiZmZlNjMuLjIyMTFmNmIgMTAwNjQ0Ci0tLSBhL2ZzL25mcy9pbm9kZS5jCisrKyBiL2ZzL25mcy9pbm9kZS5jCkBAIC0zNTIsOCArMzUyLDkgQEAKIAogCW5mc19hdHRyX2NoZWNrX21vdW50cG9pbnQoc2IsIGZhdHRyKTsKIAotCWlmICgoKGZhdHRyLT52YWxpZCAmIE5GU19BVFRSX0ZBVFRSX0ZJTEVJRCkgPT0gMCkgJiYKLQkgICAgIW5mc19hdHRyX3VzZV9tb3VudGVkX29uX2ZpbGVpZChmYXR0cikpCisJaWYgKG5mc19hdHRyX3VzZV9tb3VudGVkX29uX2ZpbGVpZChmYXR0cikpCisJCWZhdHRyLT5maWxlaWQgPSBmYXR0ci0+bW91bnRlZF9vbl9maWxlaWQ7CisJZWxzZSBpZiAoKGZhdHRyLT52YWxpZCAmIE5GU19BVFRSX0ZBVFRSX0ZJTEVJRCkgPT0gMCkKIAkJZ290byBvdXRfbm9faW5vZGU7CiAJaWYgKChmYXR0ci0+dmFsaWQgJiBORlNfQVRUUl9GQVRUUl9UWVBFKSA9PSAwKQogCQlnb3RvIG91dF9ub19pbm9kZTsKZGlmZiAtLWdpdCBhL2ZzL25mcy9pbnRlcm5hbC5oIGIvZnMvbmZzL2ludGVybmFsLmgKaW5kZXggZWZhYTMxYy4uYjZmMzRiZiAxMDA2NDQKLS0tIGEvZnMvbmZzL2ludGVybmFsLmgKKysrIGIvZnMvbmZzL2ludGVybmFsLmgKQEAgLTMxLDggKzMxLDYgQEAKIAkgICAgKCgoZmF0dHItPnZhbGlkICYgTkZTX0FUVFJfRkFUVFJfTU9VTlRQT0lOVCkgPT0gMCkgJiYKIAkgICAgICgoZmF0dHItPnZhbGlkICYgTkZTX0FUVFJfRkFUVFJfVjRfUkVGRVJSQUwpID09IDApKSkKIAkJcmV0dXJuIDA7Ci0KLQlmYXR0ci0+ZmlsZWlkID0gZmF0dHItPm1vdW50ZWRfb25fZmlsZWlkOwogCXJldHVybiAxOwogfQogCmRpZmYgLS1naXQgYS9mcy9uZnMvbmZzNGNsaWVudC5jIGIvZnMvbmZzL25mczRjbGllbnQuYwppbmRleCA5NTNkYWE0Li43MDZhZDEwIDEwMDY0NAotLS0gYS9mcy9uZnMvbmZzNGNsaWVudC5jCisrKyBiL2ZzL25mcy9uZnM0Y2xpZW50LmMKQEAgLTYzOSw3ICs2MzksNyBAQAogCQkJcHJldiA9IHBvczsKIAogCQkJc3RhdHVzID0gbmZzX3dhaXRfY2xpZW50X2luaXRfY29tcGxldGUocG9zKTsKLQkJCWlmIChzdGF0dXMgPT0gMCkgeworCQkJaWYgKHBvcy0+Y2xfY29uc19zdGF0ZSA9PSBORlNfQ1NfU0VTU0lPTl9JTklUSU5HKSB7CiAJCQkJbmZzNF9zY2hlZHVsZV9sZWFzZV9yZWNvdmVyeShwb3MpOwogCQkJCXN0YXR1cyA9IG5mczRfd2FpdF9jbG50X3JlY292ZXIocG9zKTsKIAkJCX0KZGlmZiAtLWdpdCBhL2ZzL25pbGZzMi9uaWxmcy5oIGIvZnMvbmlsZnMyL25pbGZzLmgKaW5kZXggOTEwOTNjZC4uMzg1NzA0MCAxMDA2NDQKLS0tIGEvZnMvbmlsZnMyL25pbGZzLmgKKysrIGIvZnMvbmlsZnMyL25pbGZzLmgKQEAgLTE0MSw3ICsxNDEsNiBAQAogICogQHRpX3NhdmU6IEJhY2t1cCBvZiBqb3VybmFsX2luZm8gZmllbGQgb2YgdGFza19zdHJ1Y3QKICAqIEB0aV9mbGFnczogRmxhZ3MKICAqIEB0aV9jb3VudDogTmVzdCBsZXZlbAotICogQHRpX2dhcmJhZ2U6CUxpc3Qgb2YgaW5vZGUgdG8gYmUgcHV0IHdoZW4gcmVsZWFzaW5nIHNlbWFwaG9yZQogICovCiBzdHJ1Y3QgbmlsZnNfdHJhbnNhY3Rpb25faW5mbyB7CiAJdTMyCQkJdGlfbWFnaWM7CkBAIC0xNTAsNyArMTQ5LDYgQEAKIAkJCQkgICBvbmUgb2Ygb3RoZXIgZmlsZXN5c3RlbXMgaGFzIGEgYnVnLiAqLwogCXVuc2lnbmVkIHNob3J0CQl0aV9mbGFnczsKIAl1bnNpZ25lZCBzaG9ydAkJdGlfY291bnQ7Ci0Jc3RydWN0IGxpc3RfaGVhZAl0aV9nYXJiYWdlOwogfTsKIAogLyogdGlfbWFnaWMgKi8KZGlmZiAtLWdpdCBhL2ZzL25pbGZzMi9zZWdtZW50LmMgYi9mcy9uaWxmczIvc2VnbWVudC5jCmluZGV4IDdlZjE4ZmMuLjQ2OTA4NmIgMTAwNjQ0Ci0tLSBhL2ZzL25pbGZzMi9zZWdtZW50LmMKKysrIGIvZnMvbmlsZnMyL3NlZ21lbnQuYwpAQCAtMzA1LDcgKzMwNSw2IEBACiAJdGktPnRpX2NvdW50ID0gMDsKIAl0aS0+dGlfc2F2ZSA9IGN1cl90aTsKIAl0aS0+dGlfbWFnaWMgPSBOSUxGU19USV9NQUdJQzsKLQlJTklUX0xJU1RfSEVBRCgmdGktPnRpX2dhcmJhZ2UpOwogCWN1cnJlbnQtPmpvdXJuYWxfaW5mbyA9IHRpOwogCiAJZm9yICg7OykgewpAQCAtMzMyLDggKzMzMSw2IEBACiAKIAl1cF93cml0ZSgmbmlsZnMtPm5zX3NlZ2N0b3Jfc2VtKTsKIAljdXJyZW50LT5qb3VybmFsX2luZm8gPSB0aS0+dGlfc2F2ZTsKLQlpZiAoIWxpc3RfZW1wdHkoJnRpLT50aV9nYXJiYWdlKSkKLQkJbmlsZnNfZGlzcG9zZV9saXN0KG5pbGZzLCAmdGktPnRpX2dhcmJhZ2UsIDApOwogfQogCiBzdGF0aWMgdm9pZCAqbmlsZnNfc2VnY3Rvcl9tYXBfc2Vnc3VtX2VudHJ5KHN0cnVjdCBuaWxmc19zY19pbmZvICpzY2ksCkBAIC03NDYsNiArNzQzLDE1IEBACiAJfQogfQogCitzdGF0aWMgdm9pZCBuaWxmc19pcHV0X3dvcmtfZnVuYyhzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCit7CisJc3RydWN0IG5pbGZzX3NjX2luZm8gKnNjaSA9IGNvbnRhaW5lcl9vZih3b3JrLCBzdHJ1Y3QgbmlsZnNfc2NfaW5mbywKKwkJCQkJCSBzY19pcHV0X3dvcmspOworCXN0cnVjdCB0aGVfbmlsZnMgKm5pbGZzID0gc2NpLT5zY19zdXBlci0+c19mc19pbmZvOworCisJbmlsZnNfZGlzcG9zZV9saXN0KG5pbGZzLCAmc2NpLT5zY19pcHV0X3F1ZXVlLCAwKTsKK30KKwogc3RhdGljIGludCBuaWxmc190ZXN0X21ldGFkYXRhX2RpcnR5KHN0cnVjdCB0aGVfbmlsZnMgKm5pbGZzLAogCQkJCSAgICAgc3RydWN0IG5pbGZzX3Jvb3QgKnJvb3QpCiB7CkBAIC0xOTAwLDggKzE5MDYsOCBAQAogc3RhdGljIHZvaWQgbmlsZnNfc2VnY3Rvcl9kcm9wX3dyaXR0ZW5fZmlsZXMoc3RydWN0IG5pbGZzX3NjX2luZm8gKnNjaSwKIAkJCQkJICAgICBzdHJ1Y3QgdGhlX25pbGZzICpuaWxmcykKIHsKLQlzdHJ1Y3QgbmlsZnNfdHJhbnNhY3Rpb25faW5mbyAqdGkgPSBjdXJyZW50LT5qb3VybmFsX2luZm87CiAJc3RydWN0IG5pbGZzX2lub2RlX2luZm8gKmlpLCAqbjsKKwlpbnQgZGVmZXJfaXB1dCA9IGZhbHNlOwogCiAJc3Bpbl9sb2NrKCZuaWxmcy0+bnNfaW5vZGVfbG9jayk7CiAJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKGlpLCBuLCAmc2NpLT5zY19kaXJ0eV9maWxlcywgaV9kaXJ0eSkgewpAQCAtMTkxMiw5ICsxOTE4LDI0IEBACiAJCWNsZWFyX2JpdChOSUxGU19JX0JVU1ksICZpaS0+aV9zdGF0ZSk7CiAJCWJyZWxzZShpaS0+aV9iaCk7CiAJCWlpLT5pX2JoID0gTlVMTDsKLQkJbGlzdF9tb3ZlX3RhaWwoJmlpLT5pX2RpcnR5LCAmdGktPnRpX2dhcmJhZ2UpOworCQlsaXN0X2RlbF9pbml0KCZpaS0+aV9kaXJ0eSk7CisJCWlmICghaWktPnZmc19pbm9kZS5pX25saW5rKSB7CisJCQkvKgorCQkJICogRGVmZXIgY2FsbGluZyBpcHV0KCkgdG8gYXZvaWQgYSBkZWFkbG9jaworCQkJICogb3ZlciBJX1NZTkMgZmxhZyBmb3IgaW5vZGVzIHdpdGggaV9ubGluayA9PSAwCisJCQkgKi8KKwkJCWxpc3RfYWRkX3RhaWwoJmlpLT5pX2RpcnR5LCAmc2NpLT5zY19pcHV0X3F1ZXVlKTsKKwkJCWRlZmVyX2lwdXQgPSB0cnVlOworCQl9IGVsc2UgeworCQkJc3Bpbl91bmxvY2soJm5pbGZzLT5uc19pbm9kZV9sb2NrKTsKKwkJCWlwdXQoJmlpLT52ZnNfaW5vZGUpOworCQkJc3Bpbl9sb2NrKCZuaWxmcy0+bnNfaW5vZGVfbG9jayk7CisJCX0KIAl9CiAJc3Bpbl91bmxvY2soJm5pbGZzLT5uc19pbm9kZV9sb2NrKTsKKworCWlmIChkZWZlcl9pcHV0KQorCQlzY2hlZHVsZV93b3JrKCZzY2ktPnNjX2lwdXRfd29yayk7CiB9CiAKIC8qCkBAIC0yNTgzLDYgKzI2MDQsOCBAQAogCUlOSVRfTElTVF9IRUFEKCZzY2ktPnNjX3NlZ2J1ZnMpOwogCUlOSVRfTElTVF9IRUFEKCZzY2ktPnNjX3dyaXRlX2xvZ3MpOwogCUlOSVRfTElTVF9IRUFEKCZzY2ktPnNjX2djX2lub2Rlcyk7CisJSU5JVF9MSVNUX0hFQUQoJnNjaS0+c2NfaXB1dF9xdWV1ZSk7CisJSU5JVF9XT1JLKCZzY2ktPnNjX2lwdXRfd29yaywgbmlsZnNfaXB1dF93b3JrX2Z1bmMpOwogCWluaXRfdGltZXIoJnNjaS0+c2NfdGltZXIpOwogCiAJc2NpLT5zY19pbnRlcnZhbCA9IEhaICogTklMRlNfU0NfREVGQVVMVF9USU1FT1VUOwpAQCAtMjYwOSw2ICsyNjMyLDggQEAKIAkJcmV0ID0gbmlsZnNfc2VnY3Rvcl9jb25zdHJ1Y3Qoc2NpLCBTQ19MU0VHX1NSKTsKIAkJbmlsZnNfdHJhbnNhY3Rpb25fdW5sb2NrKHNjaS0+c2Nfc3VwZXIpOwogCisJCWZsdXNoX3dvcmsoJnNjaS0+c2NfaXB1dF93b3JrKTsKKwogCX0gd2hpbGUgKHJldCAmJiByZXRyeWNvdW50LS0gPiAwKTsKIH0KIApAQCAtMjYzMyw2ICsyNjU4LDkgQEAKIAkJfHwgc2NpLT5zY19zZXFfcmVxdWVzdCAhPSBzY2ktPnNjX3NlcV9kb25lKTsKIAlzcGluX3VubG9jaygmc2NpLT5zY19zdGF0ZV9sb2NrKTsKIAorCWlmIChmbHVzaF93b3JrKCZzY2ktPnNjX2lwdXRfd29yaykpCisJCWZsYWcgPSB0cnVlOworCiAJaWYgKGZsYWcgfHwgIW5pbGZzX3NlZ2N0b3JfY29uZmlybShzY2kpKQogCQluaWxmc19zZWdjdG9yX3dyaXRlX291dChzY2kpOwogCkBAIC0yNjQyLDYgKzI2NzAsMTIgQEAKIAkJbmlsZnNfZGlzcG9zZV9saXN0KG5pbGZzLCAmc2NpLT5zY19kaXJ0eV9maWxlcywgMSk7CiAJfQogCisJaWYgKCFsaXN0X2VtcHR5KCZzY2ktPnNjX2lwdXRfcXVldWUpKSB7CisJCW5pbGZzX3dhcm5pbmcoc2NpLT5zY19zdXBlciwgX19mdW5jX18sCisJCQkgICAgICAiaXB1dCBxdWV1ZSBpcyBub3QgZW1wdHlcbiIpOworCQluaWxmc19kaXNwb3NlX2xpc3QobmlsZnMsICZzY2ktPnNjX2lwdXRfcXVldWUsIDEpOworCX0KKwogCVdBUk5fT04oIWxpc3RfZW1wdHkoJnNjaS0+c2Nfc2VnYnVmcykpOwogCVdBUk5fT04oIWxpc3RfZW1wdHkoJnNjaS0+c2Nfd3JpdGVfbG9ncykpOwogCmRpZmYgLS1naXQgYS9mcy9uaWxmczIvc2VnbWVudC5oIGIvZnMvbmlsZnMyL3NlZ21lbnQuaAppbmRleCAzOGExZDAwLi5hNDhkNmRlIDEwMDY0NAotLS0gYS9mcy9uaWxmczIvc2VnbWVudC5oCisrKyBiL2ZzL25pbGZzMi9zZWdtZW50LmgKQEAgLTI2LDYgKzI2LDcgQEAKICNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgogI2luY2x1ZGUgPGxpbnV4L2ZzLmg+CiAjaW5jbHVkZSA8bGludXgvYnVmZmVyX2hlYWQuaD4KKyNpbmNsdWRlIDxsaW51eC93b3JrcXVldWUuaD4KICNpbmNsdWRlIDxsaW51eC9uaWxmczJfZnMuaD4KICNpbmNsdWRlICJuaWxmcy5oIgogCkBAIC05Miw2ICs5Myw4IEBACiAgKiBAc2NfbmJsa19pbmM6IEJsb2NrIGNvdW50IG9mIGN1cnJlbnQgZ2VuZXJhdGlvbgogICogQHNjX2RpcnR5X2ZpbGVzOiBMaXN0IG9mIGZpbGVzIHRvIGJlIHdyaXR0ZW4KICAqIEBzY19nY19pbm9kZXM6IExpc3Qgb2YgR0MgaW5vZGVzIGhhdmluZyBibG9ja3MgdG8gYmUgd3JpdHRlbgorICogQHNjX2lwdXRfcXVldWU6IGxpc3Qgb2YgaW5vZGVzIGZvciB3aGljaCBpcHV0IHNob3VsZCBiZSBkb25lCisgKiBAc2NfaXB1dF93b3JrOiB3b3JrIHN0cnVjdCB0byBkZWZlciBpcHV0IGNhbGwKICAqIEBzY19mcmVlc2VnczogYXJyYXkgb2Ygc2VnbWVudCBudW1iZXJzIHRvIGJlIGZyZWVkCiAgKiBAc2NfbmZyZWVzZWdzOiBudW1iZXIgb2Ygc2VnbWVudHMgb24gQHNjX2ZyZWVzZWdzCiAgKiBAc2NfZHN5bmNfaW5vZGU6IGlub2RlIHdob3NlIGRhdGEgcGFnZXMgYXJlIHdyaXR0ZW4gZm9yIGEgc3luYyBvcGVyYXRpb24KQEAgLTEzNSw2ICsxMzgsOCBAQAogCiAJc3RydWN0IGxpc3RfaGVhZAlzY19kaXJ0eV9maWxlczsKIAlzdHJ1Y3QgbGlzdF9oZWFkCXNjX2djX2lub2RlczsKKwlzdHJ1Y3QgbGlzdF9oZWFkCXNjX2lwdXRfcXVldWU7CisJc3RydWN0IHdvcmtfc3RydWN0CXNjX2lwdXRfd29yazsKIAogCV9fdTY0CQkgICAgICAgKnNjX2ZyZWVzZWdzOwogCXNpemVfdAkJCXNjX25mcmVlc2VnczsKZGlmZiAtLWdpdCBhL2ZzL3F1b3RhL2RxdW90LmMgYi9mcy9xdW90YS9kcXVvdC5jCmluZGV4IDhmMGFjZWYuLjY5ZGY1YjIgMTAwNjQ0Ci0tLSBhL2ZzL3F1b3RhL2RxdW90LmMKKysrIGIvZnMvcXVvdGEvZHF1b3QuYwpAQCAtMjM5NiwzMCArMjM5NiwyNSBAQAogfQogCiAvKiBHZW5lcmljIHJvdXRpbmUgZm9yIGdldHRpbmcgY29tbW9uIHBhcnQgb2YgcXVvdGEgc3RydWN0dXJlICovCi1zdGF0aWMgdm9pZCBkb19nZXRfZHFibGsoc3RydWN0IGRxdW90ICpkcXVvdCwgc3RydWN0IGZzX2Rpc2tfcXVvdGEgKmRpKQorc3RhdGljIHZvaWQgZG9fZ2V0X2RxYmxrKHN0cnVjdCBkcXVvdCAqZHF1b3QsIHN0cnVjdCBxY19kcWJsayAqZGkpCiB7CiAJc3RydWN0IG1lbV9kcWJsayAqZG0gPSAmZHF1b3QtPmRxX2RxYjsKIAogCW1lbXNldChkaSwgMCwgc2l6ZW9mKCpkaSkpOwotCWRpLT5kX3ZlcnNpb24gPSBGU19EUVVPVF9WRVJTSU9OOwotCWRpLT5kX2ZsYWdzID0gZHF1b3QtPmRxX2lkLnR5cGUgPT0gVVNSUVVPVEEgPwotCQkJRlNfVVNFUl9RVU9UQSA6IEZTX0dST1VQX1FVT1RBOwotCWRpLT5kX2lkID0gZnJvbV9rcWlkX211bmdlZChjdXJyZW50X3VzZXJfbnMoKSwgZHF1b3QtPmRxX2lkKTsKLQogCXNwaW5fbG9jaygmZHFfZGF0YV9sb2NrKTsKLQlkaS0+ZF9ibGtfaGFyZGxpbWl0ID0gc3RvcWIoZG0tPmRxYl9iaGFyZGxpbWl0KTsKLQlkaS0+ZF9ibGtfc29mdGxpbWl0ID0gc3RvcWIoZG0tPmRxYl9ic29mdGxpbWl0KTsKKwlkaS0+ZF9zcGNfaGFyZGxpbWl0ID0gZG0tPmRxYl9iaGFyZGxpbWl0OworCWRpLT5kX3NwY19zb2Z0bGltaXQgPSBkbS0+ZHFiX2Jzb2Z0bGltaXQ7CiAJZGktPmRfaW5vX2hhcmRsaW1pdCA9IGRtLT5kcWJfaWhhcmRsaW1pdDsKIAlkaS0+ZF9pbm9fc29mdGxpbWl0ID0gZG0tPmRxYl9pc29mdGxpbWl0OwotCWRpLT5kX2Jjb3VudCA9IGRtLT5kcWJfY3Vyc3BhY2UgKyBkbS0+ZHFiX3JzdnNwYWNlOwotCWRpLT5kX2ljb3VudCA9IGRtLT5kcWJfY3VyaW5vZGVzOwotCWRpLT5kX2J0aW1lciA9IGRtLT5kcWJfYnRpbWU7Ci0JZGktPmRfaXRpbWVyID0gZG0tPmRxYl9pdGltZTsKKwlkaS0+ZF9zcGFjZSA9IGRtLT5kcWJfY3Vyc3BhY2UgKyBkbS0+ZHFiX3JzdnNwYWNlOworCWRpLT5kX2lub19jb3VudCA9IGRtLT5kcWJfY3VyaW5vZGVzOworCWRpLT5kX3NwY190aW1lciA9IGRtLT5kcWJfYnRpbWU7CisJZGktPmRfaW5vX3RpbWVyID0gZG0tPmRxYl9pdGltZTsKIAlzcGluX3VubG9jaygmZHFfZGF0YV9sb2NrKTsKIH0KIAogaW50IGRxdW90X2dldF9kcWJsayhzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCBzdHJ1Y3Qga3FpZCBxaWQsCi0JCSAgICBzdHJ1Y3QgZnNfZGlza19xdW90YSAqZGkpCisJCSAgICBzdHJ1Y3QgcWNfZHFibGsgKmRpKQogewogCXN0cnVjdCBkcXVvdCAqZHF1b3Q7CiAKQEAgLTI0MzMsNzAgKzI0MjgsNzAgQEAKIH0KIEVYUE9SVF9TWU1CT0woZHF1b3RfZ2V0X2RxYmxrKTsKIAotI2RlZmluZSBWRlNfRlNfRFFfTUFTSyBcCi0JKEZTX0RRX0JDT1VOVCB8IEZTX0RRX0JTT0ZUIHwgRlNfRFFfQkhBUkQgfCBcCi0JIEZTX0RRX0lDT1VOVCB8IEZTX0RRX0lTT0ZUIHwgRlNfRFFfSUhBUkQgfCBcCi0JIEZTX0RRX0JUSU1FUiB8IEZTX0RRX0lUSU1FUikKKyNkZWZpbmUgVkZTX1FDX01BU0sgXAorCShRQ19TUEFDRSB8IFFDX1NQQ19TT0ZUIHwgUUNfU1BDX0hBUkQgfCBcCisJIFFDX0lOT19DT1VOVCB8IFFDX0lOT19TT0ZUIHwgUUNfSU5PX0hBUkQgfCBcCisJIFFDX1NQQ19USU1FUiB8IFFDX0lOT19USU1FUikKIAogLyogR2VuZXJpYyByb3V0aW5lIGZvciBzZXR0aW5nIGNvbW1vbiBwYXJ0IG9mIHF1b3RhIHN0cnVjdHVyZSAqLwotc3RhdGljIGludCBkb19zZXRfZHFibGsoc3RydWN0IGRxdW90ICpkcXVvdCwgc3RydWN0IGZzX2Rpc2tfcXVvdGEgKmRpKQorc3RhdGljIGludCBkb19zZXRfZHFibGsoc3RydWN0IGRxdW90ICpkcXVvdCwgc3RydWN0IHFjX2RxYmxrICpkaSkKIHsKIAlzdHJ1Y3QgbWVtX2RxYmxrICpkbSA9ICZkcXVvdC0+ZHFfZHFiOwogCWludCBjaGVja19ibGltID0gMCwgY2hlY2tfaWxpbSA9IDA7CiAJc3RydWN0IG1lbV9kcWluZm8gKmRxaSA9ICZzYl9kcW9wdChkcXVvdC0+ZHFfc2IpLT5pbmZvW2RxdW90LT5kcV9pZC50eXBlXTsKIAotCWlmIChkaS0+ZF9maWVsZG1hc2sgJiB+VkZTX0ZTX0RRX01BU0spCisJaWYgKGRpLT5kX2ZpZWxkbWFzayAmIH5WRlNfUUNfTUFTSykKIAkJcmV0dXJuIC1FSU5WQUw7CiAKLQlpZiAoKChkaS0+ZF9maWVsZG1hc2sgJiBGU19EUV9CU09GVCkgJiYKLQkgICAgIChkaS0+ZF9ibGtfc29mdGxpbWl0ID4gZHFpLT5kcWlfbWF4YmxpbWl0KSkgfHwKLQkgICAgKChkaS0+ZF9maWVsZG1hc2sgJiBGU19EUV9CSEFSRCkgJiYKLQkgICAgIChkaS0+ZF9ibGtfaGFyZGxpbWl0ID4gZHFpLT5kcWlfbWF4YmxpbWl0KSkgfHwKLQkgICAgKChkaS0+ZF9maWVsZG1hc2sgJiBGU19EUV9JU09GVCkgJiYKKwlpZiAoKChkaS0+ZF9maWVsZG1hc2sgJiBRQ19TUENfU09GVCkgJiYKKwkgICAgIHN0b3FiKGRpLT5kX3NwY19zb2Z0bGltaXQpID4gZHFpLT5kcWlfbWF4YmxpbWl0KSB8fAorCSAgICAoKGRpLT5kX2ZpZWxkbWFzayAmIFFDX1NQQ19IQVJEKSAmJgorCSAgICAgc3RvcWIoZGktPmRfc3BjX2hhcmRsaW1pdCkgPiBkcWktPmRxaV9tYXhibGltaXQpIHx8CisJICAgICgoZGktPmRfZmllbGRtYXNrICYgUUNfSU5PX1NPRlQpICYmCiAJICAgICAoZGktPmRfaW5vX3NvZnRsaW1pdCA+IGRxaS0+ZHFpX21heGlsaW1pdCkpIHx8Ci0JICAgICgoZGktPmRfZmllbGRtYXNrICYgRlNfRFFfSUhBUkQpICYmCisJICAgICgoZGktPmRfZmllbGRtYXNrICYgUUNfSU5PX0hBUkQpICYmCiAJICAgICAoZGktPmRfaW5vX2hhcmRsaW1pdCA+IGRxaS0+ZHFpX21heGlsaW1pdCkpKQogCQlyZXR1cm4gLUVSQU5HRTsKIAogCXNwaW5fbG9jaygmZHFfZGF0YV9sb2NrKTsKLQlpZiAoZGktPmRfZmllbGRtYXNrICYgRlNfRFFfQkNPVU5UKSB7Ci0JCWRtLT5kcWJfY3Vyc3BhY2UgPSBkaS0+ZF9iY291bnQgLSBkbS0+ZHFiX3JzdnNwYWNlOworCWlmIChkaS0+ZF9maWVsZG1hc2sgJiBRQ19TUEFDRSkgeworCQlkbS0+ZHFiX2N1cnNwYWNlID0gZGktPmRfc3BhY2UgLSBkbS0+ZHFiX3JzdnNwYWNlOwogCQljaGVja19ibGltID0gMTsKIAkJc2V0X2JpdChEUV9MQVNUU0VUX0IgKyBRSUZfU1BBQ0VfQiwgJmRxdW90LT5kcV9mbGFncyk7CiAJfQogCi0JaWYgKGRpLT5kX2ZpZWxkbWFzayAmIEZTX0RRX0JTT0ZUKQotCQlkbS0+ZHFiX2Jzb2Z0bGltaXQgPSBxYnRvcyhkaS0+ZF9ibGtfc29mdGxpbWl0KTsKLQlpZiAoZGktPmRfZmllbGRtYXNrICYgRlNfRFFfQkhBUkQpCi0JCWRtLT5kcWJfYmhhcmRsaW1pdCA9IHFidG9zKGRpLT5kX2Jsa19oYXJkbGltaXQpOwotCWlmIChkaS0+ZF9maWVsZG1hc2sgJiAoRlNfRFFfQlNPRlQgfCBGU19EUV9CSEFSRCkpIHsKKwlpZiAoZGktPmRfZmllbGRtYXNrICYgUUNfU1BDX1NPRlQpCisJCWRtLT5kcWJfYnNvZnRsaW1pdCA9IGRpLT5kX3NwY19zb2Z0bGltaXQ7CisJaWYgKGRpLT5kX2ZpZWxkbWFzayAmIFFDX1NQQ19IQVJEKQorCQlkbS0+ZHFiX2JoYXJkbGltaXQgPSBkaS0+ZF9zcGNfaGFyZGxpbWl0OworCWlmIChkaS0+ZF9maWVsZG1hc2sgJiAoUUNfU1BDX1NPRlQgfCBRQ19TUENfSEFSRCkpIHsKIAkJY2hlY2tfYmxpbSA9IDE7CiAJCXNldF9iaXQoRFFfTEFTVFNFVF9CICsgUUlGX0JMSU1JVFNfQiwgJmRxdW90LT5kcV9mbGFncyk7CiAJfQogCi0JaWYgKGRpLT5kX2ZpZWxkbWFzayAmIEZTX0RRX0lDT1VOVCkgewotCQlkbS0+ZHFiX2N1cmlub2RlcyA9IGRpLT5kX2ljb3VudDsKKwlpZiAoZGktPmRfZmllbGRtYXNrICYgUUNfSU5PX0NPVU5UKSB7CisJCWRtLT5kcWJfY3VyaW5vZGVzID0gZGktPmRfaW5vX2NvdW50OwogCQljaGVja19pbGltID0gMTsKIAkJc2V0X2JpdChEUV9MQVNUU0VUX0IgKyBRSUZfSU5PREVTX0IsICZkcXVvdC0+ZHFfZmxhZ3MpOwogCX0KIAotCWlmIChkaS0+ZF9maWVsZG1hc2sgJiBGU19EUV9JU09GVCkKKwlpZiAoZGktPmRfZmllbGRtYXNrICYgUUNfSU5PX1NPRlQpCiAJCWRtLT5kcWJfaXNvZnRsaW1pdCA9IGRpLT5kX2lub19zb2Z0bGltaXQ7Ci0JaWYgKGRpLT5kX2ZpZWxkbWFzayAmIEZTX0RRX0lIQVJEKQorCWlmIChkaS0+ZF9maWVsZG1hc2sgJiBRQ19JTk9fSEFSRCkKIAkJZG0tPmRxYl9paGFyZGxpbWl0ID0gZGktPmRfaW5vX2hhcmRsaW1pdDsKLQlpZiAoZGktPmRfZmllbGRtYXNrICYgKEZTX0RRX0lTT0ZUIHwgRlNfRFFfSUhBUkQpKSB7CisJaWYgKGRpLT5kX2ZpZWxkbWFzayAmIChRQ19JTk9fU09GVCB8IFFDX0lOT19IQVJEKSkgewogCQljaGVja19pbGltID0gMTsKIAkJc2V0X2JpdChEUV9MQVNUU0VUX0IgKyBRSUZfSUxJTUlUU19CLCAmZHF1b3QtPmRxX2ZsYWdzKTsKIAl9CiAKLQlpZiAoZGktPmRfZmllbGRtYXNrICYgRlNfRFFfQlRJTUVSKSB7Ci0JCWRtLT5kcWJfYnRpbWUgPSBkaS0+ZF9idGltZXI7CisJaWYgKGRpLT5kX2ZpZWxkbWFzayAmIFFDX1NQQ19USU1FUikgeworCQlkbS0+ZHFiX2J0aW1lID0gZGktPmRfc3BjX3RpbWVyOwogCQljaGVja19ibGltID0gMTsKIAkJc2V0X2JpdChEUV9MQVNUU0VUX0IgKyBRSUZfQlRJTUVfQiwgJmRxdW90LT5kcV9mbGFncyk7CiAJfQogCi0JaWYgKGRpLT5kX2ZpZWxkbWFzayAmIEZTX0RRX0lUSU1FUikgewotCQlkbS0+ZHFiX2l0aW1lID0gZGktPmRfaXRpbWVyOworCWlmIChkaS0+ZF9maWVsZG1hc2sgJiBRQ19JTk9fVElNRVIpIHsKKwkJZG0tPmRxYl9pdGltZSA9IGRpLT5kX2lub190aW1lcjsKIAkJY2hlY2tfaWxpbSA9IDE7CiAJCXNldF9iaXQoRFFfTEFTVFNFVF9CICsgUUlGX0lUSU1FX0IsICZkcXVvdC0+ZHFfZmxhZ3MpOwogCX0KQEAgLTI1MDYsNyArMjUwMSw3IEBACiAJCSAgICBkbS0+ZHFiX2N1cnNwYWNlIDwgZG0tPmRxYl9ic29mdGxpbWl0KSB7CiAJCQlkbS0+ZHFiX2J0aW1lID0gMDsKIAkJCWNsZWFyX2JpdChEUV9CTEtTX0IsICZkcXVvdC0+ZHFfZmxhZ3MpOwotCQl9IGVsc2UgaWYgKCEoZGktPmRfZmllbGRtYXNrICYgRlNfRFFfQlRJTUVSKSkKKwkJfSBlbHNlIGlmICghKGRpLT5kX2ZpZWxkbWFzayAmIFFDX1NQQ19USU1FUikpCiAJCQkvKiBTZXQgZ3JhY2Ugb25seSBpZiB1c2VyIGhhc24ndCBwcm92aWRlZCBoaXMgb3duLi4uICovCiAJCQlkbS0+ZHFiX2J0aW1lID0gZ2V0X3NlY29uZHMoKSArIGRxaS0+ZHFpX2JncmFjZTsKIAl9CkBAIC0yNTE1LDcgKzI1MTAsNyBAQAogCQkgICAgZG0tPmRxYl9jdXJpbm9kZXMgPCBkbS0+ZHFiX2lzb2Z0bGltaXQpIHsKIAkJCWRtLT5kcWJfaXRpbWUgPSAwOwogCQkJY2xlYXJfYml0KERRX0lOT0RFU19CLCAmZHF1b3QtPmRxX2ZsYWdzKTsKLQkJfSBlbHNlIGlmICghKGRpLT5kX2ZpZWxkbWFzayAmIEZTX0RRX0lUSU1FUikpCisJCX0gZWxzZSBpZiAoIShkaS0+ZF9maWVsZG1hc2sgJiBRQ19JTk9fVElNRVIpKQogCQkJLyogU2V0IGdyYWNlIG9ubHkgaWYgdXNlciBoYXNuJ3QgcHJvdmlkZWQgaGlzIG93bi4uLiAqLwogCQkJZG0tPmRxYl9pdGltZSA9IGdldF9zZWNvbmRzKCkgKyBkcWktPmRxaV9pZ3JhY2U7CiAJfQpAQCAtMjUzMSw3ICsyNTI2LDcgQEAKIH0KIAogaW50IGRxdW90X3NldF9kcWJsayhzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCBzdHJ1Y3Qga3FpZCBxaWQsCi0JCSAgc3RydWN0IGZzX2Rpc2tfcXVvdGEgKmRpKQorCQkgIHN0cnVjdCBxY19kcWJsayAqZGkpCiB7CiAJc3RydWN0IGRxdW90ICpkcXVvdDsKIAlpbnQgcmM7CmRpZmYgLS1naXQgYS9mcy9xdW90YS9xdW90YS5jIGIvZnMvcXVvdGEvcXVvdGEuYwppbmRleCAyYWE0MTUxLi42ZjM4NTYzIDEwMDY0NAotLS0gYS9mcy9xdW90YS9xdW90YS5jCisrKyBiL2ZzL3F1b3RhL3F1b3RhLmMKQEAgLTExOCwxNyArMTE4LDI3IEBACiAJcmV0dXJuIHNiLT5zX3Fjb3AtPnNldF9pbmZvKHNiLCB0eXBlLCAmaW5mbyk7CiB9CiAKLXN0YXRpYyB2b2lkIGNvcHlfdG9faWZfZHFibGsoc3RydWN0IGlmX2RxYmxrICpkc3QsIHN0cnVjdCBmc19kaXNrX3F1b3RhICpzcmMpCitzdGF0aWMgaW5saW5lIHFzaXplX3QgcWJ0b3MocXNpemVfdCBibG9ja3MpCit7CisJcmV0dXJuIGJsb2NrcyA8PCBRSUZfRFFCTEtTSVpFX0JJVFM7Cit9CisKK3N0YXRpYyBpbmxpbmUgcXNpemVfdCBzdG9xYihxc2l6ZV90IHNwYWNlKQoreworCXJldHVybiAoc3BhY2UgKyBRSUZfRFFCTEtTSVpFIC0gMSkgPj4gUUlGX0RRQkxLU0laRV9CSVRTOworfQorCitzdGF0aWMgdm9pZCBjb3B5X3RvX2lmX2RxYmxrKHN0cnVjdCBpZl9kcWJsayAqZHN0LCBzdHJ1Y3QgcWNfZHFibGsgKnNyYykKIHsKIAltZW1zZXQoZHN0LCAwLCBzaXplb2YoKmRzdCkpOwotCWRzdC0+ZHFiX2JoYXJkbGltaXQgPSBzcmMtPmRfYmxrX2hhcmRsaW1pdDsKLQlkc3QtPmRxYl9ic29mdGxpbWl0ID0gc3JjLT5kX2Jsa19zb2Z0bGltaXQ7Ci0JZHN0LT5kcWJfY3Vyc3BhY2UgPSBzcmMtPmRfYmNvdW50OworCWRzdC0+ZHFiX2JoYXJkbGltaXQgPSBzdG9xYihzcmMtPmRfc3BjX2hhcmRsaW1pdCk7CisJZHN0LT5kcWJfYnNvZnRsaW1pdCA9IHN0b3FiKHNyYy0+ZF9zcGNfc29mdGxpbWl0KTsKKwlkc3QtPmRxYl9jdXJzcGFjZSA9IHNyYy0+ZF9zcGFjZTsKIAlkc3QtPmRxYl9paGFyZGxpbWl0ID0gc3JjLT5kX2lub19oYXJkbGltaXQ7CiAJZHN0LT5kcWJfaXNvZnRsaW1pdCA9IHNyYy0+ZF9pbm9fc29mdGxpbWl0OwotCWRzdC0+ZHFiX2N1cmlub2RlcyA9IHNyYy0+ZF9pY291bnQ7Ci0JZHN0LT5kcWJfYnRpbWUgPSBzcmMtPmRfYnRpbWVyOwotCWRzdC0+ZHFiX2l0aW1lID0gc3JjLT5kX2l0aW1lcjsKKwlkc3QtPmRxYl9jdXJpbm9kZXMgPSBzcmMtPmRfaW5vX2NvdW50OworCWRzdC0+ZHFiX2J0aW1lID0gc3JjLT5kX3NwY190aW1lcjsKKwlkc3QtPmRxYl9pdGltZSA9IHNyYy0+ZF9pbm9fdGltZXI7CiAJZHN0LT5kcWJfdmFsaWQgPSBRSUZfQUxMOwogfQogCkBAIC0xMzYsNyArMTQ2LDcgQEAKIAkJCSAgdm9pZCBfX3VzZXIgKmFkZHIpCiB7CiAJc3RydWN0IGtxaWQgcWlkOwotCXN0cnVjdCBmc19kaXNrX3F1b3RhIGZkcTsKKwlzdHJ1Y3QgcWNfZHFibGsgZmRxOwogCXN0cnVjdCBpZl9kcWJsayBpZHE7CiAJaW50IHJldDsKIApAQCAtMTU0LDM2ICsxNjQsMzYgQEAKIAlyZXR1cm4gMDsKIH0KIAotc3RhdGljIHZvaWQgY29weV9mcm9tX2lmX2RxYmxrKHN0cnVjdCBmc19kaXNrX3F1b3RhICpkc3QsIHN0cnVjdCBpZl9kcWJsayAqc3JjKQorc3RhdGljIHZvaWQgY29weV9mcm9tX2lmX2RxYmxrKHN0cnVjdCBxY19kcWJsayAqZHN0LCBzdHJ1Y3QgaWZfZHFibGsgKnNyYykKIHsKLQlkc3QtPmRfYmxrX2hhcmRsaW1pdCA9IHNyYy0+ZHFiX2JoYXJkbGltaXQ7Ci0JZHN0LT5kX2Jsa19zb2Z0bGltaXQgID0gc3JjLT5kcWJfYnNvZnRsaW1pdDsKLQlkc3QtPmRfYmNvdW50ID0gc3JjLT5kcWJfY3Vyc3BhY2U7CisJZHN0LT5kX3NwY19oYXJkbGltaXQgPSBxYnRvcyhzcmMtPmRxYl9iaGFyZGxpbWl0KTsKKwlkc3QtPmRfc3BjX3NvZnRsaW1pdCA9IHFidG9zKHNyYy0+ZHFiX2Jzb2Z0bGltaXQpOworCWRzdC0+ZF9zcGFjZSA9IHNyYy0+ZHFiX2N1cnNwYWNlOwogCWRzdC0+ZF9pbm9faGFyZGxpbWl0ID0gc3JjLT5kcWJfaWhhcmRsaW1pdDsKIAlkc3QtPmRfaW5vX3NvZnRsaW1pdCA9IHNyYy0+ZHFiX2lzb2Z0bGltaXQ7Ci0JZHN0LT5kX2ljb3VudCA9IHNyYy0+ZHFiX2N1cmlub2RlczsKLQlkc3QtPmRfYnRpbWVyID0gc3JjLT5kcWJfYnRpbWU7Ci0JZHN0LT5kX2l0aW1lciA9IHNyYy0+ZHFiX2l0aW1lOworCWRzdC0+ZF9pbm9fY291bnQgPSBzcmMtPmRxYl9jdXJpbm9kZXM7CisJZHN0LT5kX3NwY190aW1lciA9IHNyYy0+ZHFiX2J0aW1lOworCWRzdC0+ZF9pbm9fdGltZXIgPSBzcmMtPmRxYl9pdGltZTsKIAogCWRzdC0+ZF9maWVsZG1hc2sgPSAwOwogCWlmIChzcmMtPmRxYl92YWxpZCAmIFFJRl9CTElNSVRTKQotCQlkc3QtPmRfZmllbGRtYXNrIHw9IEZTX0RRX0JTT0ZUIHwgRlNfRFFfQkhBUkQ7CisJCWRzdC0+ZF9maWVsZG1hc2sgfD0gUUNfU1BDX1NPRlQgfCBRQ19TUENfSEFSRDsKIAlpZiAoc3JjLT5kcWJfdmFsaWQgJiBRSUZfU1BBQ0UpCi0JCWRzdC0+ZF9maWVsZG1hc2sgfD0gRlNfRFFfQkNPVU5UOworCQlkc3QtPmRfZmllbGRtYXNrIHw9IFFDX1NQQUNFOwogCWlmIChzcmMtPmRxYl92YWxpZCAmIFFJRl9JTElNSVRTKQotCQlkc3QtPmRfZmllbGRtYXNrIHw9IEZTX0RRX0lTT0ZUIHwgRlNfRFFfSUhBUkQ7CisJCWRzdC0+ZF9maWVsZG1hc2sgfD0gUUNfSU5PX1NPRlQgfCBRQ19JTk9fSEFSRDsKIAlpZiAoc3JjLT5kcWJfdmFsaWQgJiBRSUZfSU5PREVTKQotCQlkc3QtPmRfZmllbGRtYXNrIHw9IEZTX0RRX0lDT1VOVDsKKwkJZHN0LT5kX2ZpZWxkbWFzayB8PSBRQ19JTk9fQ09VTlQ7CiAJaWYgKHNyYy0+ZHFiX3ZhbGlkICYgUUlGX0JUSU1FKQotCQlkc3QtPmRfZmllbGRtYXNrIHw9IEZTX0RRX0JUSU1FUjsKKwkJZHN0LT5kX2ZpZWxkbWFzayB8PSBRQ19TUENfVElNRVI7CiAJaWYgKHNyYy0+ZHFiX3ZhbGlkICYgUUlGX0lUSU1FKQotCQlkc3QtPmRfZmllbGRtYXNrIHw9IEZTX0RRX0lUSU1FUjsKKwkJZHN0LT5kX2ZpZWxkbWFzayB8PSBRQ19JTk9fVElNRVI7CiB9CiAKIHN0YXRpYyBpbnQgcXVvdGFfc2V0cXVvdGEoc3RydWN0IHN1cGVyX2Jsb2NrICpzYiwgaW50IHR5cGUsIHFpZF90IGlkLAogCQkJICB2b2lkIF9fdXNlciAqYWRkcikKIHsKLQlzdHJ1Y3QgZnNfZGlza19xdW90YSBmZHE7CisJc3RydWN0IHFjX2RxYmxrIGZkcTsKIAlzdHJ1Y3QgaWZfZHFibGsgaWRxOwogCXN0cnVjdCBrcWlkIHFpZDsKIApAQCAtMjQ3LDEwICsyNTcsNzggQEAKIAlyZXR1cm4gcmV0OwogfQogCisvKgorICogWEZTIGRlZmluZXMgQkJUT0IgYW5kIEJUT0JCIG1hY3JvcyBpbnNpZGUgZnMveGZzLyBhbmQgd2UgY2Fubm90IG1vdmUgdGhlbQorICogb3V0IG9mIHRoZXJlIGFzIHhmc3Byb2dzIHJlbHkgb24gZGVmaW5pdGlvbnMgYmVpbmcgaW4gdGhhdCBoZWFkZXIgZmlsZS4gU28KKyAqIGp1c3QgZGVmaW5lIHNhbWUgZnVuY3Rpb25zIGhlcmUgZm9yIHF1b3RhIHB1cnBvc2VzLgorICovCisjZGVmaW5lIFhGU19CQl9TSElGVCA5CisKK3N0YXRpYyBpbmxpbmUgdTY0IHF1b3RhX2JidG9iKHU2NCBibG9ja3MpCit7CisJcmV0dXJuIGJsb2NrcyA8PCBYRlNfQkJfU0hJRlQ7Cit9CisKK3N0YXRpYyBpbmxpbmUgdTY0IHF1b3RhX2J0b2JiKHU2NCBieXRlcykKK3sKKwlyZXR1cm4gKGJ5dGVzICsgKDEgPDwgWEZTX0JCX1NISUZUKSAtIDEpID4+IFhGU19CQl9TSElGVDsKK30KKworc3RhdGljIHZvaWQgY29weV9mcm9tX3hmc19kcWJsayhzdHJ1Y3QgcWNfZHFibGsgKmRzdCwgc3RydWN0IGZzX2Rpc2tfcXVvdGEgKnNyYykKK3sKKwlkc3QtPmRfc3BjX2hhcmRsaW1pdCA9IHF1b3RhX2JidG9iKHNyYy0+ZF9ibGtfaGFyZGxpbWl0KTsKKwlkc3QtPmRfc3BjX3NvZnRsaW1pdCA9IHF1b3RhX2JidG9iKHNyYy0+ZF9ibGtfc29mdGxpbWl0KTsKKwlkc3QtPmRfaW5vX2hhcmRsaW1pdCA9IHNyYy0+ZF9pbm9faGFyZGxpbWl0OworCWRzdC0+ZF9pbm9fc29mdGxpbWl0ID0gc3JjLT5kX2lub19zb2Z0bGltaXQ7CisJZHN0LT5kX3NwYWNlID0gcXVvdGFfYmJ0b2Ioc3JjLT5kX2Jjb3VudCk7CisJZHN0LT5kX2lub19jb3VudCA9IHNyYy0+ZF9pY291bnQ7CisJZHN0LT5kX2lub190aW1lciA9IHNyYy0+ZF9pdGltZXI7CisJZHN0LT5kX3NwY190aW1lciA9IHNyYy0+ZF9idGltZXI7CisJZHN0LT5kX2lub193YXJucyA9IHNyYy0+ZF9pd2FybnM7CisJZHN0LT5kX3NwY193YXJucyA9IHNyYy0+ZF9id2FybnM7CisJZHN0LT5kX3J0X3NwY19oYXJkbGltaXQgPSBxdW90YV9iYnRvYihzcmMtPmRfcnRiX2hhcmRsaW1pdCk7CisJZHN0LT5kX3J0X3NwY19zb2Z0bGltaXQgPSBxdW90YV9iYnRvYihzcmMtPmRfcnRiX3NvZnRsaW1pdCk7CisJZHN0LT5kX3J0X3NwYWNlID0gcXVvdGFfYmJ0b2Ioc3JjLT5kX3J0YmNvdW50KTsKKwlkc3QtPmRfcnRfc3BjX3RpbWVyID0gc3JjLT5kX3J0YnRpbWVyOworCWRzdC0+ZF9ydF9zcGNfd2FybnMgPSBzcmMtPmRfcnRid2FybnM7CisJZHN0LT5kX2ZpZWxkbWFzayA9IDA7CisJaWYgKHNyYy0+ZF9maWVsZG1hc2sgJiBGU19EUV9JU09GVCkKKwkJZHN0LT5kX2ZpZWxkbWFzayB8PSBRQ19JTk9fU09GVDsKKwlpZiAoc3JjLT5kX2ZpZWxkbWFzayAmIEZTX0RRX0lIQVJEKQorCQlkc3QtPmRfZmllbGRtYXNrIHw9IFFDX0lOT19IQVJEOworCWlmIChzcmMtPmRfZmllbGRtYXNrICYgRlNfRFFfQlNPRlQpCisJCWRzdC0+ZF9maWVsZG1hc2sgfD0gUUNfU1BDX1NPRlQ7CisJaWYgKHNyYy0+ZF9maWVsZG1hc2sgJiBGU19EUV9CSEFSRCkKKwkJZHN0LT5kX2ZpZWxkbWFzayB8PSBRQ19TUENfSEFSRDsKKwlpZiAoc3JjLT5kX2ZpZWxkbWFzayAmIEZTX0RRX1JUQlNPRlQpCisJCWRzdC0+ZF9maWVsZG1hc2sgfD0gUUNfUlRfU1BDX1NPRlQ7CisJaWYgKHNyYy0+ZF9maWVsZG1hc2sgJiBGU19EUV9SVEJIQVJEKQorCQlkc3QtPmRfZmllbGRtYXNrIHw9IFFDX1JUX1NQQ19IQVJEOworCWlmIChzcmMtPmRfZmllbGRtYXNrICYgRlNfRFFfQlRJTUVSKQorCQlkc3QtPmRfZmllbGRtYXNrIHw9IFFDX1NQQ19USU1FUjsKKwlpZiAoc3JjLT5kX2ZpZWxkbWFzayAmIEZTX0RRX0lUSU1FUikKKwkJZHN0LT5kX2ZpZWxkbWFzayB8PSBRQ19JTk9fVElNRVI7CisJaWYgKHNyYy0+ZF9maWVsZG1hc2sgJiBGU19EUV9SVEJUSU1FUikKKwkJZHN0LT5kX2ZpZWxkbWFzayB8PSBRQ19SVF9TUENfVElNRVI7CisJaWYgKHNyYy0+ZF9maWVsZG1hc2sgJiBGU19EUV9CV0FSTlMpCisJCWRzdC0+ZF9maWVsZG1hc2sgfD0gUUNfU1BDX1dBUk5TOworCWlmIChzcmMtPmRfZmllbGRtYXNrICYgRlNfRFFfSVdBUk5TKQorCQlkc3QtPmRfZmllbGRtYXNrIHw9IFFDX0lOT19XQVJOUzsKKwlpZiAoc3JjLT5kX2ZpZWxkbWFzayAmIEZTX0RRX1JUQldBUk5TKQorCQlkc3QtPmRfZmllbGRtYXNrIHw9IFFDX1JUX1NQQ19XQVJOUzsKKwlpZiAoc3JjLT5kX2ZpZWxkbWFzayAmIEZTX0RRX0JDT1VOVCkKKwkJZHN0LT5kX2ZpZWxkbWFzayB8PSBRQ19TUEFDRTsKKwlpZiAoc3JjLT5kX2ZpZWxkbWFzayAmIEZTX0RRX0lDT1VOVCkKKwkJZHN0LT5kX2ZpZWxkbWFzayB8PSBRQ19JTk9fQ09VTlQ7CisJaWYgKHNyYy0+ZF9maWVsZG1hc2sgJiBGU19EUV9SVEJDT1VOVCkKKwkJZHN0LT5kX2ZpZWxkbWFzayB8PSBRQ19SVF9TUEFDRTsKK30KKwogc3RhdGljIGludCBxdW90YV9zZXR4cXVvdGEoc3RydWN0IHN1cGVyX2Jsb2NrICpzYiwgaW50IHR5cGUsIHFpZF90IGlkLAogCQkJICAgdm9pZCBfX3VzZXIgKmFkZHIpCiB7CiAJc3RydWN0IGZzX2Rpc2tfcXVvdGEgZmRxOworCXN0cnVjdCBxY19kcWJsayBxZHE7CiAJc3RydWN0IGtxaWQgcWlkOwogCiAJaWYgKGNvcHlfZnJvbV91c2VyKCZmZHEsIGFkZHIsIHNpemVvZihmZHEpKSkKQEAgLTI2MCwxMyArMzM4LDQ0IEBACiAJcWlkID0gbWFrZV9rcWlkKGN1cnJlbnRfdXNlcl9ucygpLCB0eXBlLCBpZCk7CiAJaWYgKCFxaWRfdmFsaWQocWlkKSkKIAkJcmV0dXJuIC1FSU5WQUw7Ci0JcmV0dXJuIHNiLT5zX3Fjb3AtPnNldF9kcWJsayhzYiwgcWlkLCAmZmRxKTsKKwljb3B5X2Zyb21feGZzX2RxYmxrKCZxZHEsICZmZHEpOworCXJldHVybiBzYi0+c19xY29wLT5zZXRfZHFibGsoc2IsIHFpZCwgJnFkcSk7Cit9CisKK3N0YXRpYyB2b2lkIGNvcHlfdG9feGZzX2RxYmxrKHN0cnVjdCBmc19kaXNrX3F1b3RhICpkc3QsIHN0cnVjdCBxY19kcWJsayAqc3JjLAorCQkJICAgICAgaW50IHR5cGUsIHFpZF90IGlkKQoreworCW1lbXNldChkc3QsIDAsIHNpemVvZigqZHN0KSk7CisJZHN0LT5kX3ZlcnNpb24gPSBGU19EUVVPVF9WRVJTSU9OOworCWRzdC0+ZF9pZCA9IGlkOworCWlmICh0eXBlID09IFVTUlFVT1RBKQorCQlkc3QtPmRfZmxhZ3MgPSBGU19VU0VSX1FVT1RBOworCWVsc2UgaWYgKHR5cGUgPT0gUFJKUVVPVEEpCisJCWRzdC0+ZF9mbGFncyA9IEZTX1BST0pfUVVPVEE7CisJZWxzZQorCQlkc3QtPmRfZmxhZ3MgPSBGU19HUk9VUF9RVU9UQTsKKwlkc3QtPmRfYmxrX2hhcmRsaW1pdCA9IHF1b3RhX2J0b2JiKHNyYy0+ZF9zcGNfaGFyZGxpbWl0KTsKKwlkc3QtPmRfYmxrX3NvZnRsaW1pdCA9IHF1b3RhX2J0b2JiKHNyYy0+ZF9zcGNfc29mdGxpbWl0KTsKKwlkc3QtPmRfaW5vX2hhcmRsaW1pdCA9IHNyYy0+ZF9pbm9faGFyZGxpbWl0OworCWRzdC0+ZF9pbm9fc29mdGxpbWl0ID0gc3JjLT5kX2lub19zb2Z0bGltaXQ7CisJZHN0LT5kX2Jjb3VudCA9IHF1b3RhX2J0b2JiKHNyYy0+ZF9zcGFjZSk7CisJZHN0LT5kX2ljb3VudCA9IHNyYy0+ZF9pbm9fY291bnQ7CisJZHN0LT5kX2l0aW1lciA9IHNyYy0+ZF9pbm9fdGltZXI7CisJZHN0LT5kX2J0aW1lciA9IHNyYy0+ZF9zcGNfdGltZXI7CisJZHN0LT5kX2l3YXJucyA9IHNyYy0+ZF9pbm9fd2FybnM7CisJZHN0LT5kX2J3YXJucyA9IHNyYy0+ZF9zcGNfd2FybnM7CisJZHN0LT5kX3J0Yl9oYXJkbGltaXQgPSBxdW90YV9idG9iYihzcmMtPmRfcnRfc3BjX2hhcmRsaW1pdCk7CisJZHN0LT5kX3J0Yl9zb2Z0bGltaXQgPSBxdW90YV9idG9iYihzcmMtPmRfcnRfc3BjX3NvZnRsaW1pdCk7CisJZHN0LT5kX3J0YmNvdW50ID0gcXVvdGFfYnRvYmIoc3JjLT5kX3J0X3NwYWNlKTsKKwlkc3QtPmRfcnRidGltZXIgPSBzcmMtPmRfcnRfc3BjX3RpbWVyOworCWRzdC0+ZF9ydGJ3YXJucyA9IHNyYy0+ZF9ydF9zcGNfd2FybnM7CiB9CiAKIHN0YXRpYyBpbnQgcXVvdGFfZ2V0eHF1b3RhKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIGludCB0eXBlLCBxaWRfdCBpZCwKIAkJCSAgIHZvaWQgX191c2VyICphZGRyKQogewogCXN0cnVjdCBmc19kaXNrX3F1b3RhIGZkcTsKKwlzdHJ1Y3QgcWNfZHFibGsgcWRxOwogCXN0cnVjdCBrcWlkIHFpZDsKIAlpbnQgcmV0OwogCkBAIC0yNzUsOCArMzg0LDExIEBACiAJcWlkID0gbWFrZV9rcWlkKGN1cnJlbnRfdXNlcl9ucygpLCB0eXBlLCBpZCk7CiAJaWYgKCFxaWRfdmFsaWQocWlkKSkKIAkJcmV0dXJuIC1FSU5WQUw7Ci0JcmV0ID0gc2ItPnNfcWNvcC0+Z2V0X2RxYmxrKHNiLCBxaWQsICZmZHEpOwotCWlmICghcmV0ICYmIGNvcHlfdG9fdXNlcihhZGRyLCAmZmRxLCBzaXplb2YoZmRxKSkpCisJcmV0ID0gc2ItPnNfcWNvcC0+Z2V0X2RxYmxrKHNiLCBxaWQsICZxZHEpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisJY29weV90b194ZnNfZHFibGsoJmZkcSwgJnFkcSwgdHlwZSwgaWQpOworCWlmIChjb3B5X3RvX3VzZXIoYWRkciwgJmZkcSwgc2l6ZW9mKGZkcSkpKQogCQlyZXR1cm4gLUVGQVVMVDsKIAlyZXR1cm4gcmV0OwogfQpkaWZmIC0tZ2l0IGEvZnMvdWRmL2ZpbGUuYyBiL2ZzL3VkZi9maWxlLmMKaW5kZXggYmIxNTc3MS4uMDhmMzU1NSAxMDA2NDQKLS0tIGEvZnMvdWRmL2ZpbGUuYworKysgYi9mcy91ZGYvZmlsZS5jCkBAIC0yMjQsNyArMjI0LDcgQEAKIHN0YXRpYyBpbnQgdWRmX3JlbGVhc2VfZmlsZShzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlscCkKIHsKIAlpZiAoZmlscC0+Zl9tb2RlICYgRk1PREVfV1JJVEUgJiYKLQkgICAgYXRvbWljX3JlYWQoJmlub2RlLT5pX3dyaXRlY291bnQpID4gMSkgeworCSAgICBhdG9taWNfcmVhZCgmaW5vZGUtPmlfd3JpdGVjb3VudCkgPT0gMSkgewogCQkvKgogCQkgKiBHcmFiIGlfbXV0ZXggdG8gYXZvaWQgcmFjZXMgd2l0aCB3cml0ZXMgY2hhbmdpbmcgaV9zaXplCiAJCSAqIHdoaWxlIHdlIGFyZSBydW5uaW5nLgpkaWZmIC0tZ2l0IGEvZnMveGZzL3hmc19xbS5oIGIvZnMveGZzL3hmc19xbS5oCmluZGV4IDNhMDdhOTMuLjQxZjZjMGIgMTAwNjQ0Ci0tLSBhL2ZzL3hmcy94ZnNfcW0uaAorKysgYi9mcy94ZnMveGZzX3FtLmgKQEAgLTE2Niw5ICsxNjYsOSBAQAogLyogcXVvdGEgb3BzICovCiBleHRlcm4gaW50CQl4ZnNfcW1fc2NhbGxfdHJ1bmNfcWZpbGVzKHN0cnVjdCB4ZnNfbW91bnQgKiwgdWludCk7CiBleHRlcm4gaW50CQl4ZnNfcW1fc2NhbGxfZ2V0cXVvdGEoc3RydWN0IHhmc19tb3VudCAqLCB4ZnNfZHFpZF90LAotCQkJCQl1aW50LCBzdHJ1Y3QgZnNfZGlza19xdW90YSAqKTsKKwkJCQkJdWludCwgc3RydWN0IHFjX2RxYmxrICopOwogZXh0ZXJuIGludAkJeGZzX3FtX3NjYWxsX3NldHFsaW0oc3RydWN0IHhmc19tb3VudCAqLCB4ZnNfZHFpZF90LCB1aW50LAotCQkJCQlzdHJ1Y3QgZnNfZGlza19xdW90YSAqKTsKKwkJCQkJc3RydWN0IHFjX2RxYmxrICopOwogZXh0ZXJuIGludAkJeGZzX3FtX3NjYWxsX2dldHFzdGF0KHN0cnVjdCB4ZnNfbW91bnQgKiwKIAkJCQkJc3RydWN0IGZzX3F1b3RhX3N0YXQgKik7CiBleHRlcm4gaW50CQl4ZnNfcW1fc2NhbGxfZ2V0cXN0YXR2KHN0cnVjdCB4ZnNfbW91bnQgKiwKZGlmZiAtLWdpdCBhL2ZzL3hmcy94ZnNfcW1fc3lzY2FsbHMuYyBiL2ZzL3hmcy94ZnNfcW1fc3lzY2FsbHMuYwppbmRleCA3NGZjYTY4Li5jYjYxNjhlIDEwMDY0NAotLS0gYS9mcy94ZnMveGZzX3FtX3N5c2NhbGxzLmMKKysrIGIvZnMveGZzL3hmc19xbV9zeXNjYWxscy5jCkBAIC0zOSw3ICszOSw2IEBACiBTVEFUSUMgaW50CXhmc19xbV9sb2dfcXVvdGFvZmZfZW5kKHhmc19tb3VudF90ICosIHhmc19xb2ZmX2xvZ2l0ZW1fdCAqLAogCQkJCQl1aW50KTsKIFNUQVRJQyB1aW50CXhmc19xbV9leHBvcnRfZmxhZ3ModWludCk7Ci1TVEFUSUMgdWludAl4ZnNfcW1fZXhwb3J0X3F0eXBlX2ZsYWdzKHVpbnQpOwogCiAvKgogICogVHVybiBvZmYgcXVvdGEgYWNjb3VudGluZyBhbmQvb3IgZW5mb3JjZW1lbnQgZm9yIGFsbCB1ZHF1b3RzIGFuZC9vcgpAQCAtNTczLDggKzU3Miw4IEBACiAJcmV0dXJuIDA7CiB9CiAKLSNkZWZpbmUgWEZTX0RRX01BU0sgXAotCShGU19EUV9MSU1JVF9NQVNLIHwgRlNfRFFfVElNRVJfTUFTSyB8IEZTX0RRX1dBUk5TX01BU0spCisjZGVmaW5lIFhGU19RQ19NQVNLIFwKKwkoUUNfTElNSVRfTUFTSyB8IFFDX1RJTUVSX01BU0sgfCBRQ19XQVJOU19NQVNLKQogCiAvKgogICogQWRqdXN0IHF1b3RhIGxpbWl0cywgYW5kIHN0YXJ0L3N0b3AgdGltZXJzIGFjY29yZGluZ2x5LgpAQCAtNTg0LDcgKzU4Myw3IEBACiAJc3RydWN0IHhmc19tb3VudAkqbXAsCiAJeGZzX2RxaWRfdAkJaWQsCiAJdWludAkJCXR5cGUsCi0JZnNfZGlza19xdW90YV90CQkqbmV3bGltKQorCXN0cnVjdCBxY19kcWJsawkJKm5ld2xpbSkKIHsKIAlzdHJ1Y3QgeGZzX3F1b3RhaW5mbwkqcSA9IG1wLT5tX3F1b3RhaW5mbzsKIAlzdHJ1Y3QgeGZzX2Rpc2tfZHF1b3QJKmRkcTsKQEAgLTU5Myw5ICs1OTIsOSBAQAogCWludAkJCWVycm9yOwogCXhmc19xY250X3QJCWhhcmQsIHNvZnQ7CiAKLQlpZiAobmV3bGltLT5kX2ZpZWxkbWFzayAmIH5YRlNfRFFfTUFTSykKKwlpZiAobmV3bGltLT5kX2ZpZWxkbWFzayAmIH5YRlNfUUNfTUFTSykKIAkJcmV0dXJuIC1FSU5WQUw7Ci0JaWYgKChuZXdsaW0tPmRfZmllbGRtYXNrICYgWEZTX0RRX01BU0spID09IDApCisJaWYgKChuZXdsaW0tPmRfZmllbGRtYXNrICYgWEZTX1FDX01BU0spID09IDApCiAJCXJldHVybiAwOwogCiAJLyoKQEAgLTYzMywxMSArNjMyLDExIEBACiAJLyoKIAkgKiBNYWtlIHN1cmUgdGhhdCBoYXJkbGltaXRzIGFyZSA+PSBzb2Z0IGxpbWl0cyBiZWZvcmUgY2hhbmdpbmcuCiAJICovCi0JaGFyZCA9IChuZXdsaW0tPmRfZmllbGRtYXNrICYgRlNfRFFfQkhBUkQpID8KLQkJKHhmc19xY250X3QpIFhGU19CQl9UT19GU0IobXAsIG5ld2xpbS0+ZF9ibGtfaGFyZGxpbWl0KSA6CisJaGFyZCA9IChuZXdsaW0tPmRfZmllbGRtYXNrICYgUUNfU1BDX0hBUkQpID8KKwkJKHhmc19xY250X3QpIFhGU19CX1RPX0ZTQihtcCwgbmV3bGltLT5kX3NwY19oYXJkbGltaXQpIDoKIAkJCWJlNjRfdG9fY3B1KGRkcS0+ZF9ibGtfaGFyZGxpbWl0KTsKLQlzb2Z0ID0gKG5ld2xpbS0+ZF9maWVsZG1hc2sgJiBGU19EUV9CU09GVCkgPwotCQkoeGZzX3FjbnRfdCkgWEZTX0JCX1RPX0ZTQihtcCwgbmV3bGltLT5kX2Jsa19zb2Z0bGltaXQpIDoKKwlzb2Z0ID0gKG5ld2xpbS0+ZF9maWVsZG1hc2sgJiBRQ19TUENfU09GVCkgPworCQkoeGZzX3FjbnRfdCkgWEZTX0JfVE9fRlNCKG1wLCBuZXdsaW0tPmRfc3BjX3NvZnRsaW1pdCkgOgogCQkJYmU2NF90b19jcHUoZGRxLT5kX2Jsa19zb2Z0bGltaXQpOwogCWlmIChoYXJkID09IDAgfHwgaGFyZCA+PSBzb2Z0KSB7CiAJCWRkcS0+ZF9ibGtfaGFyZGxpbWl0ID0gY3B1X3RvX2JlNjQoaGFyZCk7CkBAIC02NTAsMTEgKzY0OSwxMSBAQAogCX0gZWxzZSB7CiAJCXhmc19kZWJ1ZyhtcCwgImJsa2hhcmQgJUxkIDwgYmxrc29mdCAlTGQiLCBoYXJkLCBzb2Z0KTsKIAl9Ci0JaGFyZCA9IChuZXdsaW0tPmRfZmllbGRtYXNrICYgRlNfRFFfUlRCSEFSRCkgPwotCQkoeGZzX3FjbnRfdCkgWEZTX0JCX1RPX0ZTQihtcCwgbmV3bGltLT5kX3J0Yl9oYXJkbGltaXQpIDoKKwloYXJkID0gKG5ld2xpbS0+ZF9maWVsZG1hc2sgJiBRQ19SVF9TUENfSEFSRCkgPworCQkoeGZzX3FjbnRfdCkgWEZTX0JfVE9fRlNCKG1wLCBuZXdsaW0tPmRfcnRfc3BjX2hhcmRsaW1pdCkgOgogCQkJYmU2NF90b19jcHUoZGRxLT5kX3J0Yl9oYXJkbGltaXQpOwotCXNvZnQgPSAobmV3bGltLT5kX2ZpZWxkbWFzayAmIEZTX0RRX1JUQlNPRlQpID8KLQkJKHhmc19xY250X3QpIFhGU19CQl9UT19GU0IobXAsIG5ld2xpbS0+ZF9ydGJfc29mdGxpbWl0KSA6CisJc29mdCA9IChuZXdsaW0tPmRfZmllbGRtYXNrICYgUUNfUlRfU1BDX1NPRlQpID8KKwkJKHhmc19xY250X3QpIFhGU19CX1RPX0ZTQihtcCwgbmV3bGltLT5kX3J0X3NwY19zb2Z0bGltaXQpIDoKIAkJCWJlNjRfdG9fY3B1KGRkcS0+ZF9ydGJfc29mdGxpbWl0KTsKIAlpZiAoaGFyZCA9PSAwIHx8IGhhcmQgPj0gc29mdCkgewogCQlkZHEtPmRfcnRiX2hhcmRsaW1pdCA9IGNwdV90b19iZTY0KGhhcmQpOwpAQCAtNjY3LDEwICs2NjYsMTAgQEAKIAkJeGZzX2RlYnVnKG1wLCAicnRiaGFyZCAlTGQgPCBydGJzb2Z0ICVMZCIsIGhhcmQsIHNvZnQpOwogCX0KIAotCWhhcmQgPSAobmV3bGltLT5kX2ZpZWxkbWFzayAmIEZTX0RRX0lIQVJEKSA/CisJaGFyZCA9IChuZXdsaW0tPmRfZmllbGRtYXNrICYgUUNfSU5PX0hBUkQpID8KIAkJKHhmc19xY250X3QpIG5ld2xpbS0+ZF9pbm9faGFyZGxpbWl0IDoKIAkJCWJlNjRfdG9fY3B1KGRkcS0+ZF9pbm9faGFyZGxpbWl0KTsKLQlzb2Z0ID0gKG5ld2xpbS0+ZF9maWVsZG1hc2sgJiBGU19EUV9JU09GVCkgPworCXNvZnQgPSAobmV3bGltLT5kX2ZpZWxkbWFzayAmIFFDX0lOT19TT0ZUKSA/CiAJCSh4ZnNfcWNudF90KSBuZXdsaW0tPmRfaW5vX3NvZnRsaW1pdCA6CiAJCQliZTY0X3RvX2NwdShkZHEtPmRfaW5vX3NvZnRsaW1pdCk7CiAJaWYgKGhhcmQgPT0gMCB8fCBoYXJkID49IHNvZnQpIHsKQEAgLTY4NywxMiArNjg2LDEyIEBACiAJLyoKIAkgKiBVcGRhdGUgd2FybmluZ3MgY291bnRlcihzKSBpZiByZXF1ZXN0ZWQKIAkgKi8KLQlpZiAobmV3bGltLT5kX2ZpZWxkbWFzayAmIEZTX0RRX0JXQVJOUykKLQkJZGRxLT5kX2J3YXJucyA9IGNwdV90b19iZTE2KG5ld2xpbS0+ZF9id2FybnMpOwotCWlmIChuZXdsaW0tPmRfZmllbGRtYXNrICYgRlNfRFFfSVdBUk5TKQotCQlkZHEtPmRfaXdhcm5zID0gY3B1X3RvX2JlMTYobmV3bGltLT5kX2l3YXJucyk7Ci0JaWYgKG5ld2xpbS0+ZF9maWVsZG1hc2sgJiBGU19EUV9SVEJXQVJOUykKLQkJZGRxLT5kX3J0Yndhcm5zID0gY3B1X3RvX2JlMTYobmV3bGltLT5kX3J0Yndhcm5zKTsKKwlpZiAobmV3bGltLT5kX2ZpZWxkbWFzayAmIFFDX1NQQ19XQVJOUykKKwkJZGRxLT5kX2J3YXJucyA9IGNwdV90b19iZTE2KG5ld2xpbS0+ZF9zcGNfd2FybnMpOworCWlmIChuZXdsaW0tPmRfZmllbGRtYXNrICYgUUNfSU5PX1dBUk5TKQorCQlkZHEtPmRfaXdhcm5zID0gY3B1X3RvX2JlMTYobmV3bGltLT5kX2lub193YXJucyk7CisJaWYgKG5ld2xpbS0+ZF9maWVsZG1hc2sgJiBRQ19SVF9TUENfV0FSTlMpCisJCWRkcS0+ZF9ydGJ3YXJucyA9IGNwdV90b19iZTE2KG5ld2xpbS0+ZF9ydF9zcGNfd2FybnMpOwogCiAJaWYgKGlkID09IDApIHsKIAkJLyoKQEAgLTcwMiwyNCArNzAxLDI0IEBACiAJCSAqIHNvZnQgYW5kIGhhcmQgbGltaXQgdmFsdWVzIChhbHJlYWR5IGRvbmUsIGFib3ZlKSwgYW5kCiAJCSAqIGZvciB3YXJuaW5ncy4KIAkJICovCi0JCWlmIChuZXdsaW0tPmRfZmllbGRtYXNrICYgRlNfRFFfQlRJTUVSKSB7Ci0JCQlxLT5xaV9idGltZWxpbWl0ID0gbmV3bGltLT5kX2J0aW1lcjsKLQkJCWRkcS0+ZF9idGltZXIgPSBjcHVfdG9fYmUzMihuZXdsaW0tPmRfYnRpbWVyKTsKKwkJaWYgKG5ld2xpbS0+ZF9maWVsZG1hc2sgJiBRQ19TUENfVElNRVIpIHsKKwkJCXEtPnFpX2J0aW1lbGltaXQgPSBuZXdsaW0tPmRfc3BjX3RpbWVyOworCQkJZGRxLT5kX2J0aW1lciA9IGNwdV90b19iZTMyKG5ld2xpbS0+ZF9zcGNfdGltZXIpOwogCQl9Ci0JCWlmIChuZXdsaW0tPmRfZmllbGRtYXNrICYgRlNfRFFfSVRJTUVSKSB7Ci0JCQlxLT5xaV9pdGltZWxpbWl0ID0gbmV3bGltLT5kX2l0aW1lcjsKLQkJCWRkcS0+ZF9pdGltZXIgPSBjcHVfdG9fYmUzMihuZXdsaW0tPmRfaXRpbWVyKTsKKwkJaWYgKG5ld2xpbS0+ZF9maWVsZG1hc2sgJiBRQ19JTk9fVElNRVIpIHsKKwkJCXEtPnFpX2l0aW1lbGltaXQgPSBuZXdsaW0tPmRfaW5vX3RpbWVyOworCQkJZGRxLT5kX2l0aW1lciA9IGNwdV90b19iZTMyKG5ld2xpbS0+ZF9pbm9fdGltZXIpOwogCQl9Ci0JCWlmIChuZXdsaW0tPmRfZmllbGRtYXNrICYgRlNfRFFfUlRCVElNRVIpIHsKLQkJCXEtPnFpX3J0YnRpbWVsaW1pdCA9IG5ld2xpbS0+ZF9ydGJ0aW1lcjsKLQkJCWRkcS0+ZF9ydGJ0aW1lciA9IGNwdV90b19iZTMyKG5ld2xpbS0+ZF9ydGJ0aW1lcik7CisJCWlmIChuZXdsaW0tPmRfZmllbGRtYXNrICYgUUNfUlRfU1BDX1RJTUVSKSB7CisJCQlxLT5xaV9ydGJ0aW1lbGltaXQgPSBuZXdsaW0tPmRfcnRfc3BjX3RpbWVyOworCQkJZGRxLT5kX3J0YnRpbWVyID0gY3B1X3RvX2JlMzIobmV3bGltLT5kX3J0X3NwY190aW1lcik7CiAJCX0KLQkJaWYgKG5ld2xpbS0+ZF9maWVsZG1hc2sgJiBGU19EUV9CV0FSTlMpCi0JCQlxLT5xaV9id2FybmxpbWl0ID0gbmV3bGltLT5kX2J3YXJuczsKLQkJaWYgKG5ld2xpbS0+ZF9maWVsZG1hc2sgJiBGU19EUV9JV0FSTlMpCi0JCQlxLT5xaV9pd2FybmxpbWl0ID0gbmV3bGltLT5kX2l3YXJuczsKLQkJaWYgKG5ld2xpbS0+ZF9maWVsZG1hc2sgJiBGU19EUV9SVEJXQVJOUykKLQkJCXEtPnFpX3J0Yndhcm5saW1pdCA9IG5ld2xpbS0+ZF9ydGJ3YXJuczsKKwkJaWYgKG5ld2xpbS0+ZF9maWVsZG1hc2sgJiBRQ19TUENfV0FSTlMpCisJCQlxLT5xaV9id2FybmxpbWl0ID0gbmV3bGltLT5kX3NwY193YXJuczsKKwkJaWYgKG5ld2xpbS0+ZF9maWVsZG1hc2sgJiBRQ19JTk9fV0FSTlMpCisJCQlxLT5xaV9pd2FybmxpbWl0ID0gbmV3bGltLT5kX2lub193YXJuczsKKwkJaWYgKG5ld2xpbS0+ZF9maWVsZG1hc2sgJiBRQ19SVF9TUENfV0FSTlMpCisJCQlxLT5xaV9ydGJ3YXJubGltaXQgPSBuZXdsaW0tPmRfcnRfc3BjX3dhcm5zOwogCX0gZWxzZSB7CiAJCS8qCiAJCSAqIElmIHRoZSB1c2VyIGlzIG5vdyBvdmVyIHF1b3RhLCBzdGFydCB0aGUgdGltZWxpbWl0LgpAQCAtODI0LDcgKzgyMyw3IEBACiAJc3RydWN0IHhmc19tb3VudAkqbXAsCiAJeGZzX2RxaWRfdAkJaWQsCiAJdWludAkJCXR5cGUsCi0Jc3RydWN0IGZzX2Rpc2tfcXVvdGEJKmRzdCkKKwlzdHJ1Y3QgcWNfZHFibGsJCSpkc3QpCiB7CiAJc3RydWN0IHhmc19kcXVvdAkqZHFwOwogCWludAkJCWVycm9yOwpAQCAtODQ4LDI4ICs4NDcsMjUgQEAKIAl9CiAKIAltZW1zZXQoZHN0LCAwLCBzaXplb2YoKmRzdCkpOwotCWRzdC0+ZF92ZXJzaW9uID0gRlNfRFFVT1RfVkVSU0lPTjsKLQlkc3QtPmRfZmxhZ3MgPSB4ZnNfcW1fZXhwb3J0X3F0eXBlX2ZsYWdzKGRxcC0+cV9jb3JlLmRfZmxhZ3MpOwotCWRzdC0+ZF9pZCA9IGJlMzJfdG9fY3B1KGRxcC0+cV9jb3JlLmRfaWQpOwotCWRzdC0+ZF9ibGtfaGFyZGxpbWl0ID0KLQkJWEZTX0ZTQl9UT19CQihtcCwgYmU2NF90b19jcHUoZHFwLT5xX2NvcmUuZF9ibGtfaGFyZGxpbWl0KSk7Ci0JZHN0LT5kX2Jsa19zb2Z0bGltaXQgPQotCQlYRlNfRlNCX1RPX0JCKG1wLCBiZTY0X3RvX2NwdShkcXAtPnFfY29yZS5kX2Jsa19zb2Z0bGltaXQpKTsKKwlkc3QtPmRfc3BjX2hhcmRsaW1pdCA9CisJCVhGU19GU0JfVE9fQihtcCwgYmU2NF90b19jcHUoZHFwLT5xX2NvcmUuZF9ibGtfaGFyZGxpbWl0KSk7CisJZHN0LT5kX3NwY19zb2Z0bGltaXQgPQorCQlYRlNfRlNCX1RPX0IobXAsIGJlNjRfdG9fY3B1KGRxcC0+cV9jb3JlLmRfYmxrX3NvZnRsaW1pdCkpOwogCWRzdC0+ZF9pbm9faGFyZGxpbWl0ID0gYmU2NF90b19jcHUoZHFwLT5xX2NvcmUuZF9pbm9faGFyZGxpbWl0KTsKIAlkc3QtPmRfaW5vX3NvZnRsaW1pdCA9IGJlNjRfdG9fY3B1KGRxcC0+cV9jb3JlLmRfaW5vX3NvZnRsaW1pdCk7Ci0JZHN0LT5kX2Jjb3VudCA9IFhGU19GU0JfVE9fQkIobXAsIGRxcC0+cV9yZXNfYmNvdW50KTsKLQlkc3QtPmRfaWNvdW50ID0gZHFwLT5xX3Jlc19pY291bnQ7Ci0JZHN0LT5kX2J0aW1lciA9IGJlMzJfdG9fY3B1KGRxcC0+cV9jb3JlLmRfYnRpbWVyKTsKLQlkc3QtPmRfaXRpbWVyID0gYmUzMl90b19jcHUoZHFwLT5xX2NvcmUuZF9pdGltZXIpOwotCWRzdC0+ZF9pd2FybnMgPSBiZTE2X3RvX2NwdShkcXAtPnFfY29yZS5kX2l3YXJucyk7Ci0JZHN0LT5kX2J3YXJucyA9IGJlMTZfdG9fY3B1KGRxcC0+cV9jb3JlLmRfYndhcm5zKTsKLQlkc3QtPmRfcnRiX2hhcmRsaW1pdCA9Ci0JCVhGU19GU0JfVE9fQkIobXAsIGJlNjRfdG9fY3B1KGRxcC0+cV9jb3JlLmRfcnRiX2hhcmRsaW1pdCkpOwotCWRzdC0+ZF9ydGJfc29mdGxpbWl0ID0KLQkJWEZTX0ZTQl9UT19CQihtcCwgYmU2NF90b19jcHUoZHFwLT5xX2NvcmUuZF9ydGJfc29mdGxpbWl0KSk7Ci0JZHN0LT5kX3J0YmNvdW50ID0gWEZTX0ZTQl9UT19CQihtcCwgZHFwLT5xX3Jlc19ydGJjb3VudCk7Ci0JZHN0LT5kX3J0YnRpbWVyID0gYmUzMl90b19jcHUoZHFwLT5xX2NvcmUuZF9ydGJ0aW1lcik7Ci0JZHN0LT5kX3J0Yndhcm5zID0gYmUxNl90b19jcHUoZHFwLT5xX2NvcmUuZF9ydGJ3YXJucyk7CisJZHN0LT5kX3NwYWNlID0gWEZTX0ZTQl9UT19CKG1wLCBkcXAtPnFfcmVzX2Jjb3VudCk7CisJZHN0LT5kX2lub19jb3VudCA9IGRxcC0+cV9yZXNfaWNvdW50OworCWRzdC0+ZF9zcGNfdGltZXIgPSBiZTMyX3RvX2NwdShkcXAtPnFfY29yZS5kX2J0aW1lcik7CisJZHN0LT5kX2lub190aW1lciA9IGJlMzJfdG9fY3B1KGRxcC0+cV9jb3JlLmRfaXRpbWVyKTsKKwlkc3QtPmRfaW5vX3dhcm5zID0gYmUxNl90b19jcHUoZHFwLT5xX2NvcmUuZF9pd2FybnMpOworCWRzdC0+ZF9zcGNfd2FybnMgPSBiZTE2X3RvX2NwdShkcXAtPnFfY29yZS5kX2J3YXJucyk7CisJZHN0LT5kX3J0X3NwY19oYXJkbGltaXQgPQorCQlYRlNfRlNCX1RPX0IobXAsIGJlNjRfdG9fY3B1KGRxcC0+cV9jb3JlLmRfcnRiX2hhcmRsaW1pdCkpOworCWRzdC0+ZF9ydF9zcGNfc29mdGxpbWl0ID0KKwkJWEZTX0ZTQl9UT19CKG1wLCBiZTY0X3RvX2NwdShkcXAtPnFfY29yZS5kX3J0Yl9zb2Z0bGltaXQpKTsKKwlkc3QtPmRfcnRfc3BhY2UgPSBYRlNfRlNCX1RPX0IobXAsIGRxcC0+cV9yZXNfcnRiY291bnQpOworCWRzdC0+ZF9ydF9zcGNfdGltZXIgPSBiZTMyX3RvX2NwdShkcXAtPnFfY29yZS5kX3J0YnRpbWVyKTsKKwlkc3QtPmRfcnRfc3BjX3dhcm5zID0gYmUxNl90b19jcHUoZHFwLT5xX2NvcmUuZF9ydGJ3YXJucyk7CiAKIAkvKgogCSAqIEludGVybmFsbHksIHdlIGRvbid0IHJlc2V0IGFsbCB0aGUgdGltZXJzIHdoZW4gcXVvdGEgZW5mb3JjZW1lbnQKQEAgLTg4MiwyMyArODc4LDIzIEBACiAJICAgICBkcXAtPnFfY29yZS5kX2ZsYWdzID09IFhGU19EUV9HUk9VUCkgfHwKIAkgICAgKCFYRlNfSVNfUFFVT1RBX0VORk9SQ0VEKG1wKSAmJgogCSAgICAgZHFwLT5xX2NvcmUuZF9mbGFncyA9PSBYRlNfRFFfUFJPSikpIHsKLQkJZHN0LT5kX2J0aW1lciA9IDA7Ci0JCWRzdC0+ZF9pdGltZXIgPSAwOwotCQlkc3QtPmRfcnRidGltZXIgPSAwOworCQlkc3QtPmRfc3BjX3RpbWVyID0gMDsKKwkJZHN0LT5kX2lub190aW1lciA9IDA7CisJCWRzdC0+ZF9ydF9zcGNfdGltZXIgPSAwOwogCX0KIAogI2lmZGVmIERFQlVHCi0JaWYgKCgoWEZTX0lTX1VRVU9UQV9FTkZPUkNFRChtcCkgJiYgZHN0LT5kX2ZsYWdzID09IEZTX1VTRVJfUVVPVEEpIHx8Ci0JICAgICAoWEZTX0lTX0dRVU9UQV9FTkZPUkNFRChtcCkgJiYgZHN0LT5kX2ZsYWdzID09IEZTX0dST1VQX1FVT1RBKSB8fAotCSAgICAgKFhGU19JU19QUVVPVEFfRU5GT1JDRUQobXApICYmIGRzdC0+ZF9mbGFncyA9PSBGU19QUk9KX1FVT1RBKSkgJiYKLQkgICAgZHN0LT5kX2lkICE9IDApIHsKLQkJaWYgKChkc3QtPmRfYmNvdW50ID4gZHN0LT5kX2Jsa19zb2Z0bGltaXQpICYmCi0JCSAgICAoZHN0LT5kX2Jsa19zb2Z0bGltaXQgPiAwKSkgewotCQkJQVNTRVJUKGRzdC0+ZF9idGltZXIgIT0gMCk7CisJaWYgKCgoWEZTX0lTX1VRVU9UQV9FTkZPUkNFRChtcCkgJiYgdHlwZSA9PSBYRlNfRFFfVVNFUikgfHwKKwkgICAgIChYRlNfSVNfR1FVT1RBX0VORk9SQ0VEKG1wKSAmJiB0eXBlID09IFhGU19EUV9HUk9VUCkgfHwKKwkgICAgIChYRlNfSVNfUFFVT1RBX0VORk9SQ0VEKG1wKSAmJiB0eXBlID09IFhGU19EUV9QUk9KKSkgJiYKKwkgICAgaWQgIT0gMCkgeworCQlpZiAoKGRzdC0+ZF9zcGFjZSA+IGRzdC0+ZF9zcGNfc29mdGxpbWl0KSAmJgorCQkgICAgKGRzdC0+ZF9zcGNfc29mdGxpbWl0ID4gMCkpIHsKKwkJCUFTU0VSVChkc3QtPmRfc3BjX3RpbWVyICE9IDApOwogCQl9Ci0JCWlmICgoZHN0LT5kX2ljb3VudCA+IGRzdC0+ZF9pbm9fc29mdGxpbWl0KSAmJgorCQlpZiAoKGRzdC0+ZF9pbm9fY291bnQgPiBkc3QtPmRfaW5vX3NvZnRsaW1pdCkgJiYKIAkJICAgIChkc3QtPmRfaW5vX3NvZnRsaW1pdCA+IDApKSB7Ci0JCQlBU1NFUlQoZHN0LT5kX2l0aW1lciAhPSAwKTsKKwkJCUFTU0VSVChkc3QtPmRfaW5vX3RpbWVyICE9IDApOwogCQl9CiAJfQogI2VuZGlmCkBAIC05MDgsMjYgKzkwNCw2IEBACiB9CiAKIFNUQVRJQyB1aW50Ci14ZnNfcW1fZXhwb3J0X3F0eXBlX2ZsYWdzKAotCXVpbnQgZmxhZ3MpCi17Ci0JLyoKLQkgKiBDYW4ndCBiZSBtb3JlIHRoYW4gb25lLCBvciBub25lLgotCSAqLwotCUFTU0VSVCgoZmxhZ3MgJiAoRlNfUFJPSl9RVU9UQSB8IEZTX1VTRVJfUVVPVEEpKSAhPQotCQkoRlNfUFJPSl9RVU9UQSB8IEZTX1VTRVJfUVVPVEEpKTsKLQlBU1NFUlQoKGZsYWdzICYgKEZTX1BST0pfUVVPVEEgfCBGU19HUk9VUF9RVU9UQSkpICE9Ci0JCShGU19QUk9KX1FVT1RBIHwgRlNfR1JPVVBfUVVPVEEpKTsKLQlBU1NFUlQoKGZsYWdzICYgKEZTX1VTRVJfUVVPVEEgfCBGU19HUk9VUF9RVU9UQSkpICE9Ci0JCShGU19VU0VSX1FVT1RBIHwgRlNfR1JPVVBfUVVPVEEpKTsKLQlBU1NFUlQoKGZsYWdzICYgKEZTX1BST0pfUVVPVEF8RlNfVVNFUl9RVU9UQXxGU19HUk9VUF9RVU9UQSkpICE9IDApOwotCi0JcmV0dXJuIChmbGFncyAmIFhGU19EUV9VU0VSKSA/Ci0JCUZTX1VTRVJfUVVPVEEgOiAoZmxhZ3MgJiBYRlNfRFFfUFJPSikgPwotCQkJRlNfUFJPSl9RVU9UQSA6IEZTX0dST1VQX1FVT1RBOwotfQotCi1TVEFUSUMgdWludAogeGZzX3FtX2V4cG9ydF9mbGFncygKIAl1aW50IGZsYWdzKQogewpkaWZmIC0tZ2l0IGEvZnMveGZzL3hmc19xdW90YW9wcy5jIGIvZnMveGZzL3hmc19xdW90YW9wcy5jCmluZGV4IDc1NDJiYmUuLjgwMWE4NGMgMTAwNjQ0Ci0tLSBhL2ZzL3hmcy94ZnNfcXVvdGFvcHMuYworKysgYi9mcy94ZnMveGZzX3F1b3Rhb3BzLmMKQEAgLTEzMSw3ICsxMzEsNyBAQAogeGZzX2ZzX2dldF9kcWJsaygKIAlzdHJ1Y3Qgc3VwZXJfYmxvY2sJKnNiLAogCXN0cnVjdCBrcWlkCQlxaWQsCi0Jc3RydWN0IGZzX2Rpc2tfcXVvdGEJKmZkcSkKKwlzdHJ1Y3QgcWNfZHFibGsJCSpxZHEpCiB7CiAJc3RydWN0IHhmc19tb3VudAkqbXAgPSBYRlNfTShzYik7CiAKQEAgLTE0MSwxNCArMTQxLDE0IEBACiAJCXJldHVybiAtRVNSQ0g7CiAKIAlyZXR1cm4geGZzX3FtX3NjYWxsX2dldHF1b3RhKG1wLCBmcm9tX2txaWQoJmluaXRfdXNlcl9ucywgcWlkKSwKLQkJCQkgICAgICB4ZnNfcXVvdGFfdHlwZShxaWQudHlwZSksIGZkcSk7CisJCQkJICAgICAgeGZzX3F1b3RhX3R5cGUocWlkLnR5cGUpLCBxZHEpOwogfQogCiBTVEFUSUMgaW50CiB4ZnNfZnNfc2V0X2RxYmxrKAogCXN0cnVjdCBzdXBlcl9ibG9jawkqc2IsCiAJc3RydWN0IGtxaWQJCXFpZCwKLQlzdHJ1Y3QgZnNfZGlza19xdW90YQkqZmRxKQorCXN0cnVjdCBxY19kcWJsawkJKnFkcSkKIHsKIAlzdHJ1Y3QgeGZzX21vdW50CSptcCA9IFhGU19NKHNiKTsKIApAQCAtMTYwLDcgKzE2MCw3IEBACiAJCXJldHVybiAtRVNSQ0g7CiAKIAlyZXR1cm4geGZzX3FtX3NjYWxsX3NldHFsaW0obXAsIGZyb21fa3FpZCgmaW5pdF91c2VyX25zLCBxaWQpLAotCQkJCSAgICAgeGZzX3F1b3RhX3R5cGUocWlkLnR5cGUpLCBmZHEpOworCQkJCSAgICAgeGZzX3F1b3RhX3R5cGUocWlkLnR5cGUpLCBxZHEpOwogfQogCiBjb25zdCBzdHJ1Y3QgcXVvdGFjdGxfb3BzIHhmc19xdW90YWN0bF9vcGVyYXRpb25zID0gewpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9hY3BpL2FjYnVmZmVyLmggYi9pbmNsdWRlL2FjcGkvYWNidWZmZXIuaAppbmRleCBkNWVjNmM4Li42YjA0MGY0IDEwMDY0NAotLS0gYS9pbmNsdWRlL2FjcGkvYWNidWZmZXIuaAorKysgYi9pbmNsdWRlL2FjcGkvYWNidWZmZXIuaApAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2luY2x1ZGUvYWNwaS9hY2NvbmZpZy5oIGIvaW5jbHVkZS9hY3BpL2FjY29uZmlnLmgKaW5kZXggNWEwYTNlNS4uMDNhYWNmYiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9hY3BpL2FjY29uZmlnLmgKKysrIGIvaW5jbHVkZS9hY3BpL2FjY29uZmlnLmgKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9pbmNsdWRlL2FjcGkvYWNleGNlcC5oIGIvaW5jbHVkZS9hY3BpL2FjZXhjZXAuaAppbmRleCA4YjA2ZTRjLi4xMWMzYTAxIDEwMDY0NAotLS0gYS9pbmNsdWRlL2FjcGkvYWNleGNlcC5oCisrKyBiL2luY2x1ZGUvYWNwaS9hY2V4Y2VwLmgKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9pbmNsdWRlL2FjcGkvYWNuYW1lcy5oIGIvaW5jbHVkZS9hY3BpL2FjbmFtZXMuaAppbmRleCA3NDYxMzI3Li4yNzNkZTcwIDEwMDY0NAotLS0gYS9pbmNsdWRlL2FjcGkvYWNuYW1lcy5oCisrKyBiL2luY2x1ZGUvYWNwaS9hY25hbWVzLmgKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9pbmNsdWRlL2FjcGkvYWNvdXRwdXQuaCBiL2luY2x1ZGUvYWNwaS9hY291dHB1dC5oCmluZGV4IDFiYWFlNmUuLjkzMThhODcgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvYWNwaS9hY291dHB1dC5oCisrKyBiL2luY2x1ZGUvYWNwaS9hY291dHB1dC5oCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9hY3BpL2FjcGkuaCBiL2luY2x1ZGUvYWNwaS9hY3BpLmgKaW5kZXggYTA4ZTU1YS4uYjBiYjMwZSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9hY3BpL2FjcGkuaAorKysgYi9pbmNsdWRlL2FjcGkvYWNwaS5oCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9hY3BpL2FjcGlvc3hmLmggYi9pbmNsdWRlL2FjcGkvYWNwaW9zeGYuaAppbmRleCAwM2IzZTZkLi4wYmM3OGRmIDEwMDY0NAotLS0gYS9pbmNsdWRlL2FjcGkvYWNwaW9zeGYuaAorKysgYi9pbmNsdWRlL2FjcGkvYWNwaW9zeGYuaApAQCAtNyw3ICs3LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2luY2x1ZGUvYWNwaS9hY3BpeGYuaCBiL2luY2x1ZGUvYWNwaS9hY3BpeGYuaAppbmRleCA1YmE3ODQ2Li5kNTZmNWQ3IDEwMDY0NAotLS0gYS9pbmNsdWRlL2FjcGkvYWNwaXhmLmgKKysrIGIvaW5jbHVkZS9hY3BpL2FjcGl4Zi5oCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApAQCAtNDYsNyArNDYsNyBAQAogCiAvKiBDdXJyZW50IEFDUElDQSBzdWJzeXN0ZW0gdmVyc2lvbiBpbiBZWVlZTU1ERCBmb3JtYXQgKi8KIAotI2RlZmluZSBBQ1BJX0NBX1ZFUlNJT04gICAgICAgICAgICAgICAgIDB4MjAxNDExMDcKKyNkZWZpbmUgQUNQSV9DQV9WRVJTSU9OICAgICAgICAgICAgICAgICAweDIwMTUwMjA0CiAKICNpbmNsdWRlIDxhY3BpL2FjY29uZmlnLmg+CiAjaW5jbHVkZSA8YWNwaS9hY3R5cGVzLmg+CkBAIC01NjksNiArNTY5LDE0IEBACiAJCQkJCQkJICBhZGRyZXNzLAogCQkJCQkJCSAgdm9pZCAqY29udGV4dCkpCiBBQ1BJX0hXX0RFUEVOREVOVF9SRVRVUk5fU1RBVFVTKGFjcGlfc3RhdHVzCisJCQkJIGFjcGlfaW5zdGFsbF9ncGVfcmF3X2hhbmRsZXIoYWNwaV9oYW5kbGUKKwkJCQkJCQkgICAgICBncGVfZGV2aWNlLAorCQkJCQkJCSAgICAgIHUzMiBncGVfbnVtYmVyLAorCQkJCQkJCSAgICAgIHUzMiB0eXBlLAorCQkJCQkJCSAgICAgIGFjcGlfZ3BlX2hhbmRsZXIKKwkJCQkJCQkgICAgICBhZGRyZXNzLAorCQkJCQkJCSAgICAgIHZvaWQgKmNvbnRleHQpKQorQUNQSV9IV19ERVBFTkRFTlRfUkVUVVJOX1NUQVRVUyhhY3BpX3N0YXR1cwogCQkJCSBhY3BpX3JlbW92ZV9ncGVfaGFuZGxlcihhY3BpX2hhbmRsZSBncGVfZGV2aWNlLAogCQkJCQkJCSB1MzIgZ3BlX251bWJlciwKIAkJCQkJCQkgYWNwaV9ncGVfaGFuZGxlcgpAQCAtODkxLDEyICs4OTksNiBAQAogQUNQSV9HTE9CQUwodTgsIGFjcGlfZ2JsX3Blcm1hbmVudF9tbWFwKTsKIAogQUNQSV9FWFRFUk5BTF9SRVRVUk5fU1RBVFVTKGFjcGlfc3RhdHVzCi0JCQkgICAgYWNwaV9nZXRfaWQoYWNwaV9oYW5kbGUgb2JqZWN0LAotCQkJCQlhY3BpX293bmVyX2lkICogb3V0X3R5cGUpKQotCi1BQ1BJX0VYVEVSTkFMX1JFVFVSTl9TVEFUVVMoYWNwaV9zdGF0dXMgYWNwaV91bmxvYWRfdGFibGVfaWQoYWNwaV9vd25lcl9pZCBpZCkpCi0KLUFDUElfRVhURVJOQUxfUkVUVVJOX1NUQVRVUyhhY3BpX3N0YXR1cwogCQkJICAgIGFjcGlfZ2V0X3RhYmxlX3dpdGhfc2l6ZShhY3BpX3N0cmluZyBzaWduYXR1cmUsCiAJCQkJCQkgICAgIHUzMiBpbnN0YW5jZSwKIAkJCQkJCSAgICAgc3RydWN0IGFjcGlfdGFibGVfaGVhZGVyCmRpZmYgLS1naXQgYS9pbmNsdWRlL2FjcGkvYWNyZXN0eXAuaCBiL2luY2x1ZGUvYWNwaS9hY3Jlc3R5cC5oCmluZGV4IGViNzYwY2EuLmViZTI0MjYgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvYWNwaS9hY3Jlc3R5cC5oCisrKyBiL2luY2x1ZGUvYWNwaS9hY3Jlc3R5cC5oCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApAQCAtMzA1LDQzICszMDUsNTEgQEAKIAl1OCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbWF4X2FkZHJlc3NfZml4ZWQ7IFwKIAl1bmlvbiBhY3BpX3Jlc291cmNlX2F0dHJpYnV0ZSAgICAgICAgICAgaW5mbzsKIAotc3RydWN0IGFjcGlfcmVzb3VyY2VfYWRkcmVzcyB7Ci1BQ1BJX1JFU09VUkNFX0FERFJFU1NfQ09NTU9OfTsKLQotc3RydWN0IGFjcGlfcmVzb3VyY2VfYWRkcmVzczE2IHsKLQlBQ1BJX1JFU09VUkNFX0FERFJFU1NfQ09NTU9OIHUxNiBncmFudWxhcml0eTsKK3N0cnVjdCBhY3BpX2FkZHJlc3MxNl9hdHRyaWJ1dGUgeworCXUxNiBncmFudWxhcml0eTsKIAl1MTYgbWluaW11bTsKIAl1MTYgbWF4aW11bTsKIAl1MTYgdHJhbnNsYXRpb25fb2Zmc2V0OwogCXUxNiBhZGRyZXNzX2xlbmd0aDsKLQlzdHJ1Y3QgYWNwaV9yZXNvdXJjZV9zb3VyY2UgcmVzb3VyY2Vfc291cmNlOwogfTsKIAotc3RydWN0IGFjcGlfcmVzb3VyY2VfYWRkcmVzczMyIHsKLQlBQ1BJX1JFU09VUkNFX0FERFJFU1NfQ09NTU9OIHUzMiBncmFudWxhcml0eTsKK3N0cnVjdCBhY3BpX2FkZHJlc3MzMl9hdHRyaWJ1dGUgeworCXUzMiBncmFudWxhcml0eTsKIAl1MzIgbWluaW11bTsKIAl1MzIgbWF4aW11bTsKIAl1MzIgdHJhbnNsYXRpb25fb2Zmc2V0OwogCXUzMiBhZGRyZXNzX2xlbmd0aDsKLQlzdHJ1Y3QgYWNwaV9yZXNvdXJjZV9zb3VyY2UgcmVzb3VyY2Vfc291cmNlOwogfTsKIAotc3RydWN0IGFjcGlfcmVzb3VyY2VfYWRkcmVzczY0IHsKLQlBQ1BJX1JFU09VUkNFX0FERFJFU1NfQ09NTU9OIHU2NCBncmFudWxhcml0eTsKLQl1NjQgbWluaW11bTsKLQl1NjQgbWF4aW11bTsKLQl1NjQgdHJhbnNsYXRpb25fb2Zmc2V0OwotCXU2NCBhZGRyZXNzX2xlbmd0aDsKLQlzdHJ1Y3QgYWNwaV9yZXNvdXJjZV9zb3VyY2UgcmVzb3VyY2Vfc291cmNlOwotfTsKLQotc3RydWN0IGFjcGlfcmVzb3VyY2VfZXh0ZW5kZWRfYWRkcmVzczY0IHsKLQlBQ1BJX1JFU09VUkNFX0FERFJFU1NfQ09NTU9OIHU4IHJldmlzaW9uX0lEOworc3RydWN0IGFjcGlfYWRkcmVzczY0X2F0dHJpYnV0ZSB7CiAJdTY0IGdyYW51bGFyaXR5OwogCXU2NCBtaW5pbXVtOwogCXU2NCBtYXhpbXVtOwogCXU2NCB0cmFuc2xhdGlvbl9vZmZzZXQ7CiAJdTY0IGFkZHJlc3NfbGVuZ3RoOworfTsKKworc3RydWN0IGFjcGlfcmVzb3VyY2VfYWRkcmVzcyB7CitBQ1BJX1JFU09VUkNFX0FERFJFU1NfQ09NTU9OfTsKKworc3RydWN0IGFjcGlfcmVzb3VyY2VfYWRkcmVzczE2IHsKKwlBQ1BJX1JFU09VUkNFX0FERFJFU1NfQ09NTU9OIHN0cnVjdCBhY3BpX2FkZHJlc3MxNl9hdHRyaWJ1dGUgYWRkcmVzczsKKwlzdHJ1Y3QgYWNwaV9yZXNvdXJjZV9zb3VyY2UgcmVzb3VyY2Vfc291cmNlOworfTsKKworc3RydWN0IGFjcGlfcmVzb3VyY2VfYWRkcmVzczMyIHsKKwlBQ1BJX1JFU09VUkNFX0FERFJFU1NfQ09NTU9OIHN0cnVjdCBhY3BpX2FkZHJlc3MzMl9hdHRyaWJ1dGUgYWRkcmVzczsKKwlzdHJ1Y3QgYWNwaV9yZXNvdXJjZV9zb3VyY2UgcmVzb3VyY2Vfc291cmNlOworfTsKKworc3RydWN0IGFjcGlfcmVzb3VyY2VfYWRkcmVzczY0IHsKKwlBQ1BJX1JFU09VUkNFX0FERFJFU1NfQ09NTU9OIHN0cnVjdCBhY3BpX2FkZHJlc3M2NF9hdHRyaWJ1dGUgYWRkcmVzczsKKwlzdHJ1Y3QgYWNwaV9yZXNvdXJjZV9zb3VyY2UgcmVzb3VyY2Vfc291cmNlOworfTsKKworc3RydWN0IGFjcGlfcmVzb3VyY2VfZXh0ZW5kZWRfYWRkcmVzczY0IHsKKwlBQ1BJX1JFU09VUkNFX0FERFJFU1NfQ09NTU9OIHU4IHJldmlzaW9uX0lEOworCXN0cnVjdCBhY3BpX2FkZHJlc3M2NF9hdHRyaWJ1dGUgYWRkcmVzczsKIAl1NjQgdHlwZV9zcGVjaWZpYzsKIH07CiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvYWNwaS9hY3RibC5oIGIvaW5jbHVkZS9hY3BpL2FjdGJsLmgKaW5kZXggYmVlMTlkOC4uZDQwODFmZSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9hY3BpL2FjdGJsLmgKKysrIGIvaW5jbHVkZS9hY3BpL2FjdGJsLmgKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9pbmNsdWRlL2FjcGkvYWN0YmwxLmggYi9pbmNsdWRlL2FjcGkvYWN0YmwxLmgKaW5kZXggMjllNzkzNy4uYjgwYjBlNiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9hY3BpL2FjdGJsMS5oCisrKyBiL2luY2x1ZGUvYWNwaS9hY3RibDEuaApAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2luY2x1ZGUvYWNwaS9hY3RibDIuaCBiL2luY2x1ZGUvYWNwaS9hY3RibDIuaAppbmRleCBlY2ZmNjI0Li5mMDZkNzVlIDEwMDY0NAotLS0gYS9pbmNsdWRlL2FjcGkvYWN0YmwyLmgKKysrIGIvaW5jbHVkZS9hY3BpL2FjdGJsMi5oCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9hY3BpL2FjdGJsMy5oIGIvaW5jbHVkZS9hY3BpL2FjdGJsMy5oCmluZGV4IDU0ODBjYjIuLjQ0MGNhODEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvYWNwaS9hY3RibDMuaAorKysgYi9pbmNsdWRlL2FjcGkvYWN0YmwzLmgKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9pbmNsdWRlL2FjcGkvYWN0eXBlcy5oIGIvaW5jbHVkZS9hY3BpL2FjdHlwZXMuaAppbmRleCBiYmVmMTczLi5iMDM0ZjEwIDEwMDY0NAotLS0gYS9pbmNsdWRlL2FjcGkvYWN0eXBlcy5oCisrKyBiL2luY2x1ZGUvYWNwaS9hY3R5cGVzLmgKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CkBAIC03NDQsNyArNzQ0LDcgQEAKIC8qCiAgKiBHUEUgaW5mbyBmbGFncyAtIFBlciBHUEUKICAqICstLS0tLS0tKy0rLSstLS0rCi0gKiB8ICA3OjQgIHwzfDJ8MTowfAorICogfCAgNzo1ICB8NHwzfDI6MHwKICAqICstLS0tLS0tKy0rLSstLS0rCiAgKiAgICAgfCAgICB8IHwgIHwKICAqICAgICB8ICAgIHwgfCAgKy0tIFR5cGUgb2YgZGlzcGF0Y2g6dG8gbWV0aG9kLCBoYW5kbGVyLCBub3RpZnksIG9yIG5vbmUKQEAgLTc1NiwxMyArNzU2LDE1IEBACiAjZGVmaW5lIEFDUElfR1BFX0RJU1BBVENIX01FVEhPRCAgICAgICAgKHU4KSAweDAxCiAjZGVmaW5lIEFDUElfR1BFX0RJU1BBVENIX0hBTkRMRVIgICAgICAgKHU4KSAweDAyCiAjZGVmaW5lIEFDUElfR1BFX0RJU1BBVENIX05PVElGWSAgICAgICAgKHU4KSAweDAzCi0jZGVmaW5lIEFDUElfR1BFX0RJU1BBVENIX01BU0sgICAgICAgICAgKHU4KSAweDAzCisjZGVmaW5lIEFDUElfR1BFX0RJU1BBVENIX1JBV19IQU5ETEVSICAgKHU4KSAweDA0CisjZGVmaW5lIEFDUElfR1BFX0RJU1BBVENIX01BU0sgICAgICAgICAgKHU4KSAweDA3CisjZGVmaW5lIEFDUElfR1BFX0RJU1BBVENIX1RZUEUoZmxhZ3MpICAgKCh1OCkgKChmbGFncykgJiBBQ1BJX0dQRV9ESVNQQVRDSF9NQVNLKSkKIAotI2RlZmluZSBBQ1BJX0dQRV9MRVZFTF9UUklHR0VSRUQgICAgICAgICh1OCkgMHgwNAorI2RlZmluZSBBQ1BJX0dQRV9MRVZFTF9UUklHR0VSRUQgICAgICAgICh1OCkgMHgwOAogI2RlZmluZSBBQ1BJX0dQRV9FREdFX1RSSUdHRVJFRCAgICAgICAgICh1OCkgMHgwMAotI2RlZmluZSBBQ1BJX0dQRV9YUlVQVF9UWVBFX01BU0sgICAgICAgICh1OCkgMHgwNAorI2RlZmluZSBBQ1BJX0dQRV9YUlVQVF9UWVBFX01BU0sgICAgICAgICh1OCkgMHgwOAogCi0jZGVmaW5lIEFDUElfR1BFX0NBTl9XQUtFICAgICAgICAgICAgICAgKHU4KSAweDA4CisjZGVmaW5lIEFDUElfR1BFX0NBTl9XQUtFICAgICAgICAgICAgICAgKHU4KSAweDEwCiAKIC8qCiAgKiBGbGFncyBmb3IgR1BFIGFuZCBMb2NrIGludGVyZmFjZXMKZGlmZiAtLWdpdCBhL2luY2x1ZGUvYWNwaS9wbGF0Zm9ybS9hY2Vudi5oIGIvaW5jbHVkZS9hY3BpL3BsYXRmb3JtL2FjZW52LmgKaW5kZXggNWY4Y2MxZi4uYWQ3NGRjNSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9hY3BpL3BsYXRmb3JtL2FjZW52LmgKKysrIGIvaW5jbHVkZS9hY3BpL3BsYXRmb3JtL2FjZW52LmgKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9pbmNsdWRlL2FjcGkvcGxhdGZvcm0vYWNlbnZleC5oIGIvaW5jbHVkZS9hY3BpL3BsYXRmb3JtL2FjZW52ZXguaAppbmRleCAyYjYxMjM4Li43MWU1ZWM1IDEwMDY0NAotLS0gYS9pbmNsdWRlL2FjcGkvcGxhdGZvcm0vYWNlbnZleC5oCisrKyBiL2luY2x1ZGUvYWNwaS9wbGF0Zm9ybS9hY2VudmV4LmgKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9pbmNsdWRlL2FjcGkvcGxhdGZvcm0vYWNnY2MuaCBiL2luY2x1ZGUvYWNwaS9wbGF0Zm9ybS9hY2djYy5oCmluZGV4IDM4NDg3NWQuLmY1NGRlMGEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvYWNwaS9wbGF0Zm9ybS9hY2djYy5oCisrKyBiL2luY2x1ZGUvYWNwaS9wbGF0Zm9ybS9hY2djYy5oCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9hY3BpL3BsYXRmb3JtL2FjbGludXguaCBiL2luY2x1ZGUvYWNwaS9wbGF0Zm9ybS9hY2xpbnV4LmgKaW5kZXggMWJhN2MxOS4uNzRiYTQ2YyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9hY3BpL3BsYXRmb3JtL2FjbGludXguaAorKysgYi9pbmNsdWRlL2FjcGkvcGxhdGZvcm0vYWNsaW51eC5oCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9hY3BpL3BsYXRmb3JtL2FjbGludXhleC5oIGIvaW5jbHVkZS9hY3BpL3BsYXRmb3JtL2FjbGludXhleC5oCmluZGV4IDU2OGQ0YjguLmFjZWRjM2YgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvYWNwaS9wbGF0Zm9ybS9hY2xpbnV4ZXguaAorKysgYi9pbmNsdWRlL2FjcGkvcGxhdGZvcm0vYWNsaW51eGV4LmgKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9pbmNsdWRlL2R0LWJpbmRpbmdzL2ludGVycnVwdC1jb250cm9sbGVyL2FybS1naWMuaCBiL2luY2x1ZGUvZHQtYmluZGluZ3MvaW50ZXJydXB0LWNvbnRyb2xsZXIvYXJtLWdpYy5oCmluZGV4IDFlYTFiNzAuLmQ0MTEwZDUgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvZHQtYmluZGluZ3MvaW50ZXJydXB0LWNvbnRyb2xsZXIvYXJtLWdpYy5oCisrKyBiL2luY2x1ZGUvZHQtYmluZGluZ3MvaW50ZXJydXB0LWNvbnRyb2xsZXIvYXJtLWdpYy5oCkBAIC03LDE0ICs3LDE0IEBACiAKICNpbmNsdWRlIDxkdC1iaW5kaW5ncy9pbnRlcnJ1cHQtY29udHJvbGxlci9pcnEuaD4KIAotLyogaW50ZXJydXB0IHNwZWNpZmljIGNlbGwgMCAqLworLyogaW50ZXJydXB0IHNwZWNpZmllciBjZWxsIDAgKi8KIAogI2RlZmluZSBHSUNfU1BJIDAKICNkZWZpbmUgR0lDX1BQSSAxCiAKIC8qCiAgKiBJbnRlcnJ1cHQgc3BlY2lmaWVyIGNlbGwgMi4KLSAqIFRoZSBmbGFnZ3MgaW4gaXJxLmggYXJlIHZhbGlkLCBwbHVzIHRob3NlIGJlbG93LgorICogVGhlIGZsYWdzIGluIGlycS5oIGFyZSB2YWxpZCwgcGx1cyB0aG9zZSBiZWxvdy4KICAqLwogI2RlZmluZSBHSUNfQ1BVX01BU0tfUkFXKHgpICgoeCkgPDwgOCkKICNkZWZpbmUgR0lDX0NQVV9NQVNLX1NJTVBMRShudW0pIEdJQ19DUFVfTUFTS19SQVcoKDEgPDwgKG51bSkpIC0gMSkKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvYWNwaS5oIGIvaW5jbHVkZS9saW51eC9hY3BpLmgKaW5kZXggZDQ1OWNkMS4uMjRjN2FhOCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9hY3BpLmgKKysrIGIvaW5jbHVkZS9saW51eC9hY3BpLmgKQEAgLTI3LDYgKzI3LDcgQEAKIAogI2luY2x1ZGUgPGxpbnV4L2Vycm5vLmg+CiAjaW5jbHVkZSA8bGludXgvaW9wb3J0Lmg+CS8qIGZvciBzdHJ1Y3QgcmVzb3VyY2UgKi8KKyNpbmNsdWRlIDxsaW51eC9yZXNvdXJjZV9leHQuaD4KICNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KICNpbmNsdWRlIDxsaW51eC9wcm9wZXJ0eS5oPgogCkBAIC0xNTEsNiArMTUyLDEwIEBACiBpbnQgYWNwaV91bm1hcF9jcHUoaW50IGNwdSk7CiAjZW5kaWYgLyogQ09ORklHX0FDUElfSE9UUExVR19DUFUgKi8KIAorI2lmZGVmIENPTkZJR19BQ1BJX0hPVFBMVUdfSU9BUElDCitpbnQgYWNwaV9nZXRfaW9hcGljX2lkKGFjcGlfaGFuZGxlIGhhbmRsZSwgdTMyIGdzaV9iYXNlLCB1NjQgKnBoeXNfYWRkcik7CisjZW5kaWYKKwogaW50IGFjcGlfcmVnaXN0ZXJfaW9hcGljKGFjcGlfaGFuZGxlIGhhbmRsZSwgdTY0IHBoeXNfYWRkciwgdTMyIGdzaV9iYXNlKTsKIGludCBhY3BpX3VucmVnaXN0ZXJfaW9hcGljKGFjcGlfaGFuZGxlIGhhbmRsZSwgdTMyIGdzaV9iYXNlKTsKIGludCBhY3BpX2lvYXBpY19yZWdpc3RlcmVkKGFjcGlfaGFuZGxlIGhhbmRsZSwgdTMyIGdzaV9iYXNlKTsKQEAgLTI4OCwyMiArMjkzLDI1IEBACiBib29sIGFjcGlfZGV2X3Jlc291cmNlX21lbW9yeShzdHJ1Y3QgYWNwaV9yZXNvdXJjZSAqYXJlcywgc3RydWN0IHJlc291cmNlICpyZXMpOwogYm9vbCBhY3BpX2Rldl9yZXNvdXJjZV9pbyhzdHJ1Y3QgYWNwaV9yZXNvdXJjZSAqYXJlcywgc3RydWN0IHJlc291cmNlICpyZXMpOwogYm9vbCBhY3BpX2Rldl9yZXNvdXJjZV9hZGRyZXNzX3NwYWNlKHN0cnVjdCBhY3BpX3Jlc291cmNlICphcmVzLAotCQkJCSAgICAgc3RydWN0IHJlc291cmNlICpyZXMpOworCQkJCSAgICAgc3RydWN0IHJlc291cmNlX3dpbiAqd2luKTsKIGJvb2wgYWNwaV9kZXZfcmVzb3VyY2VfZXh0X2FkZHJlc3Nfc3BhY2Uoc3RydWN0IGFjcGlfcmVzb3VyY2UgKmFyZXMsCi0JCQkJCSBzdHJ1Y3QgcmVzb3VyY2UgKnJlcyk7CisJCQkJCSBzdHJ1Y3QgcmVzb3VyY2Vfd2luICp3aW4pOwogdW5zaWduZWQgbG9uZyBhY3BpX2Rldl9pcnFfZmxhZ3ModTggdHJpZ2dlcmluZywgdTggcG9sYXJpdHksIHU4IHNoYXJlYWJsZSk7CiBib29sIGFjcGlfZGV2X3Jlc291cmNlX2ludGVycnVwdChzdHJ1Y3QgYWNwaV9yZXNvdXJjZSAqYXJlcywgaW50IGluZGV4LAogCQkJCSBzdHJ1Y3QgcmVzb3VyY2UgKnJlcyk7CiAKLXN0cnVjdCByZXNvdXJjZV9saXN0X2VudHJ5IHsKLQlzdHJ1Y3QgbGlzdF9oZWFkIG5vZGU7Ci0Jc3RydWN0IHJlc291cmNlIHJlczsKLX07Ci0KIHZvaWQgYWNwaV9kZXZfZnJlZV9yZXNvdXJjZV9saXN0KHN0cnVjdCBsaXN0X2hlYWQgKmxpc3QpOwogaW50IGFjcGlfZGV2X2dldF9yZXNvdXJjZXMoc3RydWN0IGFjcGlfZGV2aWNlICphZGV2LCBzdHJ1Y3QgbGlzdF9oZWFkICpsaXN0LAogCQkJICAgaW50ICgqcHJlcHJvYykoc3RydWN0IGFjcGlfcmVzb3VyY2UgKiwgdm9pZCAqKSwKIAkJCSAgIHZvaWQgKnByZXByb2NfZGF0YSk7CitpbnQgYWNwaV9kZXZfZmlsdGVyX3Jlc291cmNlX3R5cGUoc3RydWN0IGFjcGlfcmVzb3VyY2UgKmFyZXMsCisJCQkJICB1bnNpZ25lZCBsb25nIHR5cGVzKTsKKworc3RhdGljIGlubGluZSBpbnQgYWNwaV9kZXZfZmlsdGVyX3Jlc291cmNlX3R5cGVfY2Ioc3RydWN0IGFjcGlfcmVzb3VyY2UgKmFyZXMsCisJCQkJCQkgICB2b2lkICphcmcpCit7CisJcmV0dXJuIGFjcGlfZGV2X2ZpbHRlcl9yZXNvdXJjZV90eXBlKGFyZXMsICh1bnNpZ25lZCBsb25nKWFyZyk7Cit9CiAKIGludCBhY3BpX2NoZWNrX3Jlc291cmNlX2NvbmZsaWN0KGNvbnN0IHN0cnVjdCByZXNvdXJjZSAqcmVzKTsKIApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9kZXZmcmVxLWV2ZW50LmggYi9pbmNsdWRlL2xpbnV4L2RldmZyZXEtZXZlbnQuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42MDJmYmJmCi0tLSAvZGV2L251bGwKKysrIGIvaW5jbHVkZS9saW51eC9kZXZmcmVxLWV2ZW50LmgKQEAgLTAsMCArMSwxOTYgQEAKKy8qCisgKiBkZXZmcmVxLWV2ZW50OiBhIGZyYW1ld29yayB0byBwcm92aWRlIHJhdyBkYXRhIGFuZCBldmVudHMgb2YgZGV2ZnJlcSBkZXZpY2VzCisgKgorICogQ29weXJpZ2h0IChDKSAyMDE0IFNhbXN1bmcgRWxlY3Ryb25pY3MKKyAqIEF1dGhvcjogQ2hhbndvbyBDaG9pIDxjdzAwLmNob2lAc2Ftc3VuZy5jb20+CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KKyAqLworCisjaWZuZGVmIF9fTElOVVhfREVWRlJFUV9FVkVOVF9IX18KKyNkZWZpbmUgX19MSU5VWF9ERVZGUkVRX0VWRU5UX0hfXworCisjaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+CisKKy8qKgorICogc3RydWN0IGRldmZyZXFfZXZlbnRfZGV2IC0gdGhlIGRldmZyZXEtZXZlbnQgZGV2aWNlCisgKgorICogQG5vZGUJOiBDb250YWluIHRoZSBkZXZmcmVxLWV2ZW50IGRldmljZSB0aGF0IGhhdmUgYmVlbiByZWdpc3RlcmVkLgorICogQGRldgkJOiB0aGUgZGV2aWNlIHJlZ2lzdGVyZWQgYnkgZGV2ZnJlcS1ldmVudCBjbGFzcy4gZGV2LnBhcmVudCBpcworICoJCSAgdGhlIGRldmljZSB1c2luZyBkZXZmcmVxLWV2ZW50LgorICogQGxvY2sJOiBhIG11dGV4IHRvIHByb3RlY3QgYWNjZXNzaW5nIGRldmZyZXEtZXZlbnQuCisgKiBAZW5hYmxlX2NvdW50OiB0aGUgbnVtYmVyIG9mIGVuYWJsZSBmdW5jdGlvbiBoYXZlIGJlZW4gY2FsbGVkLgorICogQGRlc2MJOiB0aGUgZGVzY3JpcHRpb24gZm9yIGRldmZyZXEtZXZlbnQgZGV2aWNlLgorICoKKyAqIFRoaXMgc3RydWN0dXJlIGNvbnRhaW5zIGRldmZyZXEtZXZlbnQgZGV2aWNlIGluZm9ybWF0aW9uLgorICovCitzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kZXYgeworCXN0cnVjdCBsaXN0X2hlYWQgbm9kZTsKKworCXN0cnVjdCBkZXZpY2UgZGV2OworCXN0cnVjdCBtdXRleCBsb2NrOworCXUzMiBlbmFibGVfY291bnQ7CisKKwljb25zdCBzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kZXNjICpkZXNjOworfTsKKworLyoqCisgKiBzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kYXRhIC0gdGhlIGRldmZyZXEtZXZlbnQgZGF0YQorICoKKyAqIEBsb2FkX2NvdW50CTogbG9hZCBjb3VudCBvZiBkZXZmcmVxLWV2ZW50IGRldmljZSBmb3IgdGhlIGdpdmVuIHBlcmlvZC4KKyAqIEB0b3RhbF9jb3VudAk6IHRvdGFsIGNvdW50IG9mIGRldmZyZXEtZXZlbnQgZGV2aWNlIGZvciB0aGUgZ2l2ZW4gcGVyaW9kLgorICoJCSAgZWFjaCBjb3VudCBtYXkgcmVwcmVzZW50IGEgY2xvY2sgY3ljbGUsIGEgdGltZSB1bml0CisgKgkJICAobnMvdXMvLi4uKSwgb3IgYW55dGhpbmcgdGhlIGRldmljZSBkcml2ZXIgd2FudHMuCisgKgkJICBHZW5lcmFsbHksIHV0aWxpemF0aW9uIGlzIGxvYWRfY291bnQgLyB0b3RhbF9jb3VudC4KKyAqCisgKiBUaGlzIHN0cnVjdHVyZSBjb250YWlucyB0aGUgZGF0YSBvZiBkZXZmcmVxLWV2ZW50IGRldmljZSBmb3IgcG9sbGluZyBwZXJpb2QuCisgKi8KK3N0cnVjdCBkZXZmcmVxX2V2ZW50X2RhdGEgeworCXVuc2lnbmVkIGxvbmcgbG9hZF9jb3VudDsKKwl1bnNpZ25lZCBsb25nIHRvdGFsX2NvdW50OworfTsKKworLyoqCisgKiBzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9vcHMgLSB0aGUgb3BlcmF0aW9ucyBvZiBkZXZmcmVxLWV2ZW50IGRldmljZQorICoKKyAqIEBlbmFibGUJOiBFbmFibGUgdGhlIGRldmZyZXEtZXZlbnQgZGV2aWNlLgorICogQGRpc2FibGUJOiBEaXNhYmxlIHRoZSBkZXZmcmVxLWV2ZW50IGRldmljZS4KKyAqIEByZXNldAk6IFJlc2V0IGFsbCBzZXR0aW5nIG9mIHRoZSBkZXZmcmVxLWV2ZW50IGRldmljZS4KKyAqIEBzZXRfZXZlbnQJOiBTZXQgdGhlIHNwZWNpZmljIGV2ZW50IHR5cGUgZm9yIHRoZSBkZXZmcmVxLWV2ZW50IGRldmljZS4KKyAqIEBnZXRfZXZlbnQJOiBHZXQgdGhlIHJlc3VsdCBvZiB0aGUgZGV2ZnJlcS1ldmVudCBkZXZpZSB3aXRoIHNwZWNpZmljCisgKgkJICBldmVudCB0eXBlLgorICoKKyAqIFRoaXMgc3RydWN0dXJlIGNvbnRhaW5zIGRldmZyZXEtZXZlbnQgZGV2aWNlIG9wZXJhdGlvbnMgd2hpY2ggY2FuIGJlCisgKiBpbXBsZW1lbnRlZCBieSBkZXZmcmVxLWV2ZW50IGRldmljZSBkcml2ZXJzLgorICovCitzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9vcHMgeworCS8qIE9wdGlvbmFsIGZ1bmN0aW9ucyAqLworCWludCAoKmVuYWJsZSkoc3RydWN0IGRldmZyZXFfZXZlbnRfZGV2ICplZGV2KTsKKwlpbnQgKCpkaXNhYmxlKShzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kZXYgKmVkZXYpOworCWludCAoKnJlc2V0KShzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kZXYgKmVkZXYpOworCisJLyogTWFuZGF0b3J5IGZ1bmN0aW9ucyAqLworCWludCAoKnNldF9ldmVudCkoc3RydWN0IGRldmZyZXFfZXZlbnRfZGV2ICplZGV2KTsKKwlpbnQgKCpnZXRfZXZlbnQpKHN0cnVjdCBkZXZmcmVxX2V2ZW50X2RldiAqZWRldiwKKwkJCSBzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kYXRhICplZGF0YSk7Cit9OworCisvKioKKyAqIHN0cnVjdCBkZXZmcmVxX2V2ZW50X2Rlc2MgLSB0aGUgZGVzY3JpcHRvciBvZiBkZXZmcmVxLWV2ZW50IGRldmljZQorICoKKyAqIEBuYW1lCTogdGhlIG5hbWUgb2YgZGV2ZnJlcS1ldmVudCBkZXZpY2UuCisgKiBAZHJpdmVyX2RhdGEJOiB0aGUgcHJpdmF0ZSBkYXRhIGZvciBkZXZmcmVxLWV2ZW50IGRyaXZlci4KKyAqIEBvcHMJCTogdGhlIG9wZXJhdGlvbiB0byBjb250cm9sIGRldmZyZXEtZXZlbnQgZGV2aWNlLgorICoKKyAqIEVhY2ggZGV2ZnJlcS1ldmVudCBkZXZpY2UgaXMgZGVzY3JpYmVkIHdpdGggYSB0aGlzIHN0cnVjdHVyZS4KKyAqIFRoaXMgc3RydWN0dXJlIGNvbnRhaW5zIHRoZSB2YXJpb3VzIGRhdGEgZm9yIGRldmZyZXEtZXZlbnQgZGV2aWNlLgorICovCitzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kZXNjIHsKKwljb25zdCBjaGFyICpuYW1lOworCXZvaWQgKmRyaXZlcl9kYXRhOworCisJc3RydWN0IGRldmZyZXFfZXZlbnRfb3BzICpvcHM7Cit9OworCisjaWYgZGVmaW5lZChDT05GSUdfUE1fREVWRlJFUV9FVkVOVCkKK2V4dGVybiBpbnQgZGV2ZnJlcV9ldmVudF9lbmFibGVfZWRldihzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kZXYgKmVkZXYpOworZXh0ZXJuIGludCBkZXZmcmVxX2V2ZW50X2Rpc2FibGVfZWRldihzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kZXYgKmVkZXYpOworZXh0ZXJuIGJvb2wgZGV2ZnJlcV9ldmVudF9pc19lbmFibGVkKHN0cnVjdCBkZXZmcmVxX2V2ZW50X2RldiAqZWRldik7CitleHRlcm4gaW50IGRldmZyZXFfZXZlbnRfc2V0X2V2ZW50KHN0cnVjdCBkZXZmcmVxX2V2ZW50X2RldiAqZWRldik7CitleHRlcm4gaW50IGRldmZyZXFfZXZlbnRfZ2V0X2V2ZW50KHN0cnVjdCBkZXZmcmVxX2V2ZW50X2RldiAqZWRldiwKKwkJCQlzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kYXRhICplZGF0YSk7CitleHRlcm4gaW50IGRldmZyZXFfZXZlbnRfcmVzZXRfZXZlbnQoc3RydWN0IGRldmZyZXFfZXZlbnRfZGV2ICplZGV2KTsKK2V4dGVybiBzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kZXYgKmRldmZyZXFfZXZlbnRfZ2V0X2VkZXZfYnlfcGhhbmRsZSgKKwkJCQlzdHJ1Y3QgZGV2aWNlICpkZXYsIGludCBpbmRleCk7CitleHRlcm4gaW50IGRldmZyZXFfZXZlbnRfZ2V0X2VkZXZfY291bnQoc3RydWN0IGRldmljZSAqZGV2KTsKK2V4dGVybiBzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kZXYgKmRldmZyZXFfZXZlbnRfYWRkX2VkZXYoc3RydWN0IGRldmljZSAqZGV2LAorCQkJCXN0cnVjdCBkZXZmcmVxX2V2ZW50X2Rlc2MgKmRlc2MpOworZXh0ZXJuIGludCBkZXZmcmVxX2V2ZW50X3JlbW92ZV9lZGV2KHN0cnVjdCBkZXZmcmVxX2V2ZW50X2RldiAqZWRldik7CitleHRlcm4gc3RydWN0IGRldmZyZXFfZXZlbnRfZGV2ICpkZXZtX2RldmZyZXFfZXZlbnRfYWRkX2VkZXYoc3RydWN0IGRldmljZSAqZGV2LAorCQkJCXN0cnVjdCBkZXZmcmVxX2V2ZW50X2Rlc2MgKmRlc2MpOworZXh0ZXJuIHZvaWQgZGV2bV9kZXZmcmVxX2V2ZW50X3JlbW92ZV9lZGV2KHN0cnVjdCBkZXZpY2UgKmRldiwKKwkJCQlzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kZXYgKmVkZXYpOworc3RhdGljIGlubGluZSB2b2lkICpkZXZmcmVxX2V2ZW50X2dldF9kcnZkYXRhKHN0cnVjdCBkZXZmcmVxX2V2ZW50X2RldiAqZWRldikKK3sKKwlyZXR1cm4gZWRldi0+ZGVzYy0+ZHJpdmVyX2RhdGE7Cit9CisjZWxzZQorc3RhdGljIGlubGluZSBpbnQgZGV2ZnJlcV9ldmVudF9lbmFibGVfZWRldihzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kZXYgKmVkZXYpCit7CisJcmV0dXJuIC1FSU5WQUw7Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50IGRldmZyZXFfZXZlbnRfZGlzYWJsZV9lZGV2KHN0cnVjdCBkZXZmcmVxX2V2ZW50X2RldiAqZWRldikKK3sKKwlyZXR1cm4gLUVJTlZBTDsKK30KKworc3RhdGljIGlubGluZSBib29sIGRldmZyZXFfZXZlbnRfaXNfZW5hYmxlZChzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kZXYgKmVkZXYpCit7CisJcmV0dXJuIGZhbHNlOworfQorCitzdGF0aWMgaW5saW5lIGludCBkZXZmcmVxX2V2ZW50X3NldF9ldmVudChzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kZXYgKmVkZXYpCit7CisJcmV0dXJuIC1FSU5WQUw7Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50IGRldmZyZXFfZXZlbnRfZ2V0X2V2ZW50KHN0cnVjdCBkZXZmcmVxX2V2ZW50X2RldiAqZWRldiwKKwkJCQkJc3RydWN0IGRldmZyZXFfZXZlbnRfZGF0YSAqZWRhdGEpCit7CisJcmV0dXJuIC1FSU5WQUw7Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50IGRldmZyZXFfZXZlbnRfcmVzZXRfZXZlbnQoc3RydWN0IGRldmZyZXFfZXZlbnRfZGV2ICplZGV2KQoreworCXJldHVybiAtRUlOVkFMOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgKmRldmZyZXFfZXZlbnRfZ2V0X2RydmRhdGEoc3RydWN0IGRldmZyZXFfZXZlbnRfZGV2ICplZGV2KQoreworCXJldHVybiBFUlJfUFRSKC1FSU5WQUwpOworfQorCitzdGF0aWMgaW5saW5lIHN0cnVjdCBkZXZmcmVxX2V2ZW50X2RldiAqZGV2ZnJlcV9ldmVudF9nZXRfZWRldl9ieV9waGFuZGxlKAorCQkJCQlzdHJ1Y3QgZGV2aWNlICpkZXYsIGludCBpbmRleCkKK3sKKwlyZXR1cm4gRVJSX1BUUigtRUlOVkFMKTsKK30KKworc3RhdGljIGlubGluZSBpbnQgZGV2ZnJlcV9ldmVudF9nZXRfZWRldl9jb3VudChzdHJ1Y3QgZGV2aWNlICpkZXYpCit7CisJcmV0dXJuIC1FSU5WQUw7Cit9CisKK3N0YXRpYyBpbmxpbmUgc3RydWN0IGRldmZyZXFfZXZlbnRfZGV2ICpkZXZmcmVxX2V2ZW50X2FkZF9lZGV2KHN0cnVjdCBkZXZpY2UgKmRldiwKKwkJCQkJc3RydWN0IGRldmZyZXFfZXZlbnRfZGVzYyAqZGVzYykKK3sKKwlyZXR1cm4gRVJSX1BUUigtRUlOVkFMKTsKK30KKworc3RhdGljIGlubGluZSBpbnQgZGV2ZnJlcV9ldmVudF9yZW1vdmVfZWRldihzdHJ1Y3QgZGV2ZnJlcV9ldmVudF9kZXYgKmVkZXYpCit7CisJcmV0dXJuIC1FSU5WQUw7Cit9CisKK3N0YXRpYyBpbmxpbmUgc3RydWN0IGRldmZyZXFfZXZlbnRfZGV2ICpkZXZtX2RldmZyZXFfZXZlbnRfYWRkX2VkZXYoCisJCQkJCXN0cnVjdCBkZXZpY2UgKmRldiwKKwkJCQkJc3RydWN0IGRldmZyZXFfZXZlbnRfZGVzYyAqZGVzYykKK3sKKwlyZXR1cm4gRVJSX1BUUigtRUlOVkFMKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGRldm1fZGV2ZnJlcV9ldmVudF9yZW1vdmVfZWRldihzdHJ1Y3QgZGV2aWNlICpkZXYsCisJCQkJCXN0cnVjdCBkZXZmcmVxX2V2ZW50X2RldiAqZWRldikKK3sKK30KKworc3RhdGljIGlubGluZSB2b2lkICpkZXZmcmVxX2V2ZW50X2dldF9kcnZkYXRhKHN0cnVjdCBkZXZmcmVxX2V2ZW50X2RldiAqZWRldikKK3sKKwlyZXR1cm4gTlVMTDsKK30KKyNlbmRpZiAvKiBDT05GSUdfUE1fREVWRlJFUV9FVkVOVCAqLworCisjZW5kaWYgLyogX19MSU5VWF9ERVZGUkVRX0VWRU5UX0hfXyAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9nZW5ldGxpbmsuaCBiL2luY2x1ZGUvbGludXgvZ2VuZXRsaW5rLmgKaW5kZXggNTViNjg1Ny4uMDk0NjBkNiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9nZW5ldGxpbmsuaAorKysgYi9pbmNsdWRlL2xpbnV4L2dlbmV0bGluay5oCkBAIC0xMSw2ICsxMSwxMCBAQAogZXh0ZXJuIGludCBsb2NrZGVwX2dlbmxfaXNfaGVsZCh2b2lkKTsKICNlbmRpZgogCisvKiBmb3Igc3luY2hyb25pc2F0aW9uIGJldHdlZW4gYWZfbmV0bGluayBhbmQgZ2VuZXRsaW5rICovCitleHRlcm4gYXRvbWljX3QgZ2VubF9za19kZXN0cnVjdGluZ19jbnQ7CitleHRlcm4gd2FpdF9xdWV1ZV9oZWFkX3QgZ2VubF9za19kZXN0cnVjdGluZ193YWl0cTsKKwogLyoqCiAgKiByY3VfZGVyZWZlcmVuY2VfZ2VubCAtIHJjdV9kZXJlZmVyZW5jZSB3aXRoIGRlYnVnIGNoZWNraW5nCiAgKiBAcDogVGhlIHBvaW50ZXIgdG8gcmVhZCwgcHJpb3IgdG8gZGVyZWZlcmVuY2luZwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9pMmMuaCBiL2luY2x1ZGUvbGludXgvaTJjLmgKaW5kZXggZTNhMTcyMS4uN2M3Njk1OSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9pMmMuaAorKysgYi9pbmNsdWRlL2xpbnV4L2kyYy5oCkBAIC0yMjgsNyArMjI4LDkgQEAKIAlzdHJ1Y3QgZGV2aWNlIGRldjsJCS8qIHRoZSBkZXZpY2Ugc3RydWN0dXJlCQkqLwogCWludCBpcnE7CQkJLyogaXJxIGlzc3VlZCBieSBkZXZpY2UJCSovCiAJc3RydWN0IGxpc3RfaGVhZCBkZXRlY3RlZDsKKyNpZiBJU19FTkFCTEVEKENPTkZJR19JMkNfU0xBVkUpCiAJaTJjX3NsYXZlX2NiX3Qgc2xhdmVfY2I7CS8qIGNhbGxiYWNrIGZvciBzbGF2ZSBtb2RlCSovCisjZW5kaWYKIH07CiAjZGVmaW5lIHRvX2kyY19jbGllbnQoZCkgY29udGFpbmVyX29mKGQsIHN0cnVjdCBpMmNfY2xpZW50LCBkZXYpCiAKQEAgLTI1Myw2ICsyNTUsNyBAQAogCiAvKiBJMkMgc2xhdmUgc3VwcG9ydCAqLwogCisjaWYgSVNfRU5BQkxFRChDT05GSUdfSTJDX1NMQVZFKQogZW51bSBpMmNfc2xhdmVfZXZlbnQgewogCUkyQ19TTEFWRV9SRVFfUkVBRF9TVEFSVCwKIAlJMkNfU0xBVkVfUkVRX1JFQURfRU5ELApAQCAtMjY5LDYgKzI3Miw3IEBACiB7CiAJcmV0dXJuIGNsaWVudC0+c2xhdmVfY2IoY2xpZW50LCBldmVudCwgdmFsKTsKIH0KKyNlbmRpZgogCiAvKioKICAqIHN0cnVjdCBpMmNfYm9hcmRfaW5mbyAtIHRlbXBsYXRlIGZvciBkZXZpY2UgY3JlYXRpb24KQEAgLTQwNCw4ICs0MDgsMTAgQEAKIAkvKiBUbyBkZXRlcm1pbmUgd2hhdCB0aGUgYWRhcHRlciBzdXBwb3J0cyAqLwogCXUzMiAoKmZ1bmN0aW9uYWxpdHkpIChzdHJ1Y3QgaTJjX2FkYXB0ZXIgKik7CiAKKyNpZiBJU19FTkFCTEVEKENPTkZJR19JMkNfU0xBVkUpCiAJaW50ICgqcmVnX3NsYXZlKShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50KTsKIAlpbnQgKCp1bnJlZ19zbGF2ZSkoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCk7CisjZW5kaWYKIH07CiAKIC8qKgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9pZl92bGFuLmggYi9pbmNsdWRlL2xpbnV4L2lmX3ZsYW4uaAppbmRleCA1MTVhMzVlMi4uOTYwZTY2NiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9pZl92bGFuLmgKKysrIGIvaW5jbHVkZS9saW51eC9pZl92bGFuLmgKQEAgLTQ3MiwyNyArNDcyLDU5IEBACiAvKioKICAqIHZsYW5fZ2V0X3Byb3RvY29sIC0gZ2V0IHByb3RvY29sIEV0aGVyVHlwZS4KICAqIEBza2I6IHNrYnVmZiB0byBxdWVyeQorICogQHR5cGU6IGZpcnN0IHZsYW4gcHJvdG9jb2wKKyAqIEBkZXB0aDogYnVmZmVyIHRvIHN0b3JlIGxlbmd0aCBvZiBldGggYW5kIHZsYW4gdGFncyBpbiBieXRlcwogICoKICAqIFJldHVybnMgdGhlIEV0aGVyVHlwZSBvZiB0aGUgcGFja2V0LCByZWdhcmRsZXNzIG9mIHdoZXRoZXIgaXQgaXMKICAqIHZsYW4gZW5jYXBzdWxhdGVkIChub3JtYWwgb3IgaGFyZHdhcmUgYWNjZWxlcmF0ZWQpIG9yIG5vdC4KICAqLwotc3RhdGljIGlubGluZSBfX2JlMTYgdmxhbl9nZXRfcHJvdG9jb2woY29uc3Qgc3RydWN0IHNrX2J1ZmYgKnNrYikKK3N0YXRpYyBpbmxpbmUgX19iZTE2IF9fdmxhbl9nZXRfcHJvdG9jb2woc3RydWN0IHNrX2J1ZmYgKnNrYiwgX19iZTE2IHR5cGUsCisJCQkJCSBpbnQgKmRlcHRoKQogewotCV9fYmUxNiBwcm90b2NvbCA9IDA7CisJdW5zaWduZWQgaW50IHZsYW5fZGVwdGggPSBza2ItPm1hY19sZW47CiAKLQlpZiAodmxhbl90eF90YWdfcHJlc2VudChza2IpIHx8Ci0JICAgICBza2ItPnByb3RvY29sICE9IGNwdV90b19iZTE2KEVUSF9QXzgwMjFRKSkKLQkJcHJvdG9jb2wgPSBza2ItPnByb3RvY29sOwotCWVsc2UgewotCQlfX2JlMTYgcHJvdG8sICpwcm90b3A7Ci0JCXByb3RvcCA9IHNrYl9oZWFkZXJfcG9pbnRlcihza2IsIG9mZnNldG9mKHN0cnVjdCB2bGFuX2V0aGhkciwKLQkJCQkJCWhfdmxhbl9lbmNhcHN1bGF0ZWRfcHJvdG8pLAotCQkJCQkJc2l6ZW9mKHByb3RvKSwgJnByb3RvKTsKLQkJaWYgKGxpa2VseShwcm90b3ApKQotCQkJcHJvdG9jb2wgPSAqcHJvdG9wOworCS8qIGlmIHR5cGUgaXMgODAyLjFRL0FEIHRoZW4gdGhlIGhlYWRlciBzaG91bGQgYWxyZWFkeSBiZQorCSAqIHByZXNlbnQgYXQgbWFjX2xlbiAtIFZMQU5fSExFTiAoaWYgbWFjX2xlbiA+IDApLCBvciBhdAorCSAqIEVUSF9ITEVOIG90aGVyd2lzZQorCSAqLworCWlmICh0eXBlID09IGh0b25zKEVUSF9QXzgwMjFRKSB8fCB0eXBlID09IGh0b25zKEVUSF9QXzgwMjFBRCkpIHsKKwkJaWYgKHZsYW5fZGVwdGgpIHsKKwkJCWlmIChXQVJOX09OKHZsYW5fZGVwdGggPCBWTEFOX0hMRU4pKQorCQkJCXJldHVybiAwOworCQkJdmxhbl9kZXB0aCAtPSBWTEFOX0hMRU47CisJCX0gZWxzZSB7CisJCQl2bGFuX2RlcHRoID0gRVRIX0hMRU47CisJCX0KKwkJZG8geworCQkJc3RydWN0IHZsYW5faGRyICp2aDsKKworCQkJaWYgKHVubGlrZWx5KCFwc2tiX21heV9wdWxsKHNrYiwKKwkJCQkJCSAgICB2bGFuX2RlcHRoICsgVkxBTl9ITEVOKSkpCisJCQkJcmV0dXJuIDA7CisKKwkJCXZoID0gKHN0cnVjdCB2bGFuX2hkciAqKShza2ItPmRhdGEgKyB2bGFuX2RlcHRoKTsKKwkJCXR5cGUgPSB2aC0+aF92bGFuX2VuY2Fwc3VsYXRlZF9wcm90bzsKKwkJCXZsYW5fZGVwdGggKz0gVkxBTl9ITEVOOworCQl9IHdoaWxlICh0eXBlID09IGh0b25zKEVUSF9QXzgwMjFRKSB8fAorCQkJIHR5cGUgPT0gaHRvbnMoRVRIX1BfODAyMUFEKSk7CiAJfQogCi0JcmV0dXJuIHByb3RvY29sOworCWlmIChkZXB0aCkKKwkJKmRlcHRoID0gdmxhbl9kZXB0aDsKKworCXJldHVybiB0eXBlOworfQorCisvKioKKyAqIHZsYW5fZ2V0X3Byb3RvY29sIC0gZ2V0IHByb3RvY29sIEV0aGVyVHlwZS4KKyAqIEBza2I6IHNrYnVmZiB0byBxdWVyeQorICoKKyAqIFJldHVybnMgdGhlIEV0aGVyVHlwZSBvZiB0aGUgcGFja2V0LCByZWdhcmRsZXNzIG9mIHdoZXRoZXIgaXQgaXMKKyAqIHZsYW4gZW5jYXBzdWxhdGVkIChub3JtYWwgb3IgaGFyZHdhcmUgYWNjZWxlcmF0ZWQpIG9yIG5vdC4KKyAqLworc3RhdGljIGlubGluZSBfX2JlMTYgdmxhbl9nZXRfcHJvdG9jb2woc3RydWN0IHNrX2J1ZmYgKnNrYikKK3sKKwlyZXR1cm4gX192bGFuX2dldF9wcm90b2NvbChza2IsIHNrYi0+cHJvdG9jb2wsIE5VTEwpOwogfQogCiBzdGF0aWMgaW5saW5lIHZvaWQgdmxhbl9zZXRfZW5jYXBfcHJvdG8oc3RydWN0IHNrX2J1ZmYgKnNrYiwKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgva2VybmVsLmggYi9pbmNsdWRlL2xpbnV4L2tlcm5lbC5oCmluZGV4IDU0NDlkMmYuLjY0Y2U1OGIgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgva2VybmVsLmgKKysrIGIvaW5jbHVkZS9saW51eC9rZXJuZWwuaApAQCAtMTc2LDcgKzE3Niw3IEBACiAgKi8KICMgZGVmaW5lIG1pZ2h0X3NsZWVwKCkgXAogCWRvIHsgX19taWdodF9zbGVlcChfX0ZJTEVfXywgX19MSU5FX18sIDApOyBtaWdodF9yZXNjaGVkKCk7IH0gd2hpbGUgKDApCi0jIGRlZmluZSBzY2hlZF9hbm5vdGF0ZV9zbGVlcCgpCV9fc2V0X2N1cnJlbnRfc3RhdGUoVEFTS19SVU5OSU5HKQorIyBkZWZpbmUgc2NoZWRfYW5ub3RhdGVfc2xlZXAoKQkoY3VycmVudC0+dGFza19zdGF0ZV9jaGFuZ2UgPSAwKQogI2Vsc2UKICAgc3RhdGljIGlubGluZSB2b2lkIF9fX21pZ2h0X3NsZWVwKGNvbnN0IGNoYXIgKmZpbGUsIGludCBsaW5lLAogCQkJCSAgIGludCBwcmVlbXB0X29mZnNldCkgeyB9CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2xpYmF0YS5oIGIvaW5jbHVkZS9saW51eC9saWJhdGEuaAppbmRleCAyZDE4MjQxLi45MWY3MDVkIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2xpYmF0YS5oCisrKyBiL2luY2x1ZGUvbGludXgvbGliYXRhLmgKQEAgLTIzMSw2ICsyMzEsNyBAQAogCUFUQV9GTEFHX1NXX0FDVElWSVRZCT0gKDEgPDwgMjIpLCAvKiBkcml2ZXIgc3VwcG9ydHMgc3cgYWN0aXZpdHkKIAkJCQkJICAgICAgKiBsZWQgKi8KIAlBVEFfRkxBR19OT19ESVBNCT0gKDEgPDwgMjMpLCAvKiBob3N0IG5vdCBoYXBweSB3aXRoIERJUE0gKi8KKwlBVEFfRkxBR19MT1dUQUcJCT0gKDEgPDwgMjQpLCAvKiBob3N0IHdhbnRzIGxvd2VzdCBhdmFpbGFibGUgdGFnICovCiAKIAkvKiBiaXRzIDI0OjMxIG9mIGFwLT5mbGFncyBhcmUgcmVzZXJ2ZWQgZm9yIExMRCBzcGVjaWZpYyBmbGFncyAqLwogCkBAIC00MjIsNiArNDIzLDcgQEAKIAlBVEFfSE9SS0FHRV9OT19OQ1FfVFJJTQk9ICgxIDw8IDE5KSwJLyogZG9uJ3QgdXNlIHF1ZXVlZCBUUklNICovCiAJQVRBX0hPUktBR0VfTk9MUE0JPSAoMSA8PCAyMCksCS8qIGRvbid0IHVzZSBMUE0gKi8KIAlBVEFfSE9SS0FHRV9XRF9CUk9LRU5fTFBNID0gKDEgPDwgMjEpLAkvKiBzb21lIFdEcyBoYXZlIGJyb2tlbiBMUE0gKi8KKwlBVEFfSE9SS0FHRV9aRVJPX0FGVEVSX1RSSU0gPSAoMSA8PCAyMiksLyogZ3VhcmFudGVlcyB6ZXJvIGFmdGVyIHRyaW0gKi8KIAogCSAvKiBETUEgbWFzayBmb3IgdXNlciBETUEgY29udHJvbDogVXNlciB2aXNpYmxlIHZhbHVlczsgRE8gTk9UCiAJICAgIHJlbnVtYmVyICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L21mZC9zYW1zdW5nL3MybXBzMTMuaCBiL2luY2x1ZGUvbGludXgvbWZkL3NhbXN1bmcvczJtcHMxMy5oCmluZGV4IGNlNWRkYTguLmIxZmQ2NzUgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbWZkL3NhbXN1bmcvczJtcHMxMy5oCisrKyBiL2luY2x1ZGUvbGludXgvbWZkL3NhbXN1bmcvczJtcHMxMy5oCkBAIC01OSw2ICs1OSw3IEBACiAJUzJNUFMxM19SRUdfQjZDVFJMLAogCVMyTVBTMTNfUkVHX0I2T1VULAogCVMyTVBTMTNfUkVHX0I3Q1RSTCwKKwlTMk1QUzEzX1JFR19CN1NXLAogCVMyTVBTMTNfUkVHX0I3T1VULAogCVMyTVBTMTNfUkVHX0I4Q1RSTCwKIAlTMk1QUzEzX1JFR19COE9VVCwKQEAgLTEwMiw2ICsxMDMsNyBAQAogCVMyTVBTMTNfUkVHX0wyNkNUUkwsCiAJUzJNUFMxM19SRUdfTDI3Q1RSTCwKIAlTMk1QUzEzX1JFR19MMjhDVFJMLAorCVMyTVBTMTNfUkVHX0wyOUNUUkwsCiAJUzJNUFMxM19SRUdfTDMwQ1RSTCwKIAlTMk1QUzEzX1JFR19MMzFDVFJMLAogCVMyTVBTMTNfUkVHX0wzMkNUUkwsCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L21seDQvZGV2aWNlLmggYi9pbmNsdWRlL2xpbnV4L21seDQvZGV2aWNlLmgKaW5kZXggMjVjNzkxZS4uNWYzYTlhYSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9tbHg0L2RldmljZS5oCisrKyBiL2luY2x1ZGUvbGludXgvbWx4NC9kZXZpY2UuaApAQCAtOTcsNyArOTcsNyBAQAogCU1MWDRfTUFYX05VTV9QRgkJPSAxNiwKIAlNTFg0X01BWF9OVU1fVkYJCT0gMTI2LAogCU1MWDRfTUFYX05VTV9WRl9QX1BPUlQgID0gNjQsCi0JTUxYNF9NRlVOQ19NQVgJCT0gODAsCisJTUxYNF9NRlVOQ19NQVgJCT0gMTI4LAogCU1MWDRfTUFYX0VRX05VTQkJPSAxMDI0LAogCU1MWDRfTUZVTkNfRVFfTlVNCT0gNCwKIAlNTFg0X01GVU5DX01BWF9FUUVTICAgICA9IDgsCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L21tLmggYi9pbmNsdWRlL2xpbnV4L21tLmgKaW5kZXggODBmYzkyYS4uZGQ1ZWEzMCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9tbS5oCisrKyBiL2luY2x1ZGUvbGludXgvbW0uaApAQCAtMTA3MCw2ICsxMDcwLDcgQEAKICNkZWZpbmUgVk1fRkFVTFRfV1JJVEUJMHgwMDA4CS8qIFNwZWNpYWwgY2FzZSBmb3IgZ2V0X3VzZXJfcGFnZXMgKi8KICNkZWZpbmUgVk1fRkFVTFRfSFdQT0lTT04gMHgwMDEwCS8qIEhpdCBwb2lzb25lZCBzbWFsbCBwYWdlICovCiAjZGVmaW5lIFZNX0ZBVUxUX0hXUE9JU09OX0xBUkdFIDB4MDAyMCAgLyogSGl0IHBvaXNvbmVkIGxhcmdlIHBhZ2UuIEluZGV4IGVuY29kZWQgaW4gdXBwZXIgYml0cyAqLworI2RlZmluZSBWTV9GQVVMVF9TSUdTRUdWIDB4MDA0MAogCiAjZGVmaW5lIFZNX0ZBVUxUX05PUEFHRQkweDAxMDAJLyogLT5mYXVsdCBpbnN0YWxsZWQgdGhlIHB0ZSwgbm90IHJldHVybiBwYWdlICovCiAjZGVmaW5lIFZNX0ZBVUxUX0xPQ0tFRAkweDAyMDAJLyogLT5mYXVsdCBsb2NrZWQgdGhlIHJldHVybmVkIHBhZ2UgKi8KQEAgLTEwNzgsOCArMTA3OSw5IEBACiAKICNkZWZpbmUgVk1fRkFVTFRfSFdQT0lTT05fTEFSR0VfTUFTSyAweGYwMDAgLyogZW5jb2RlcyBocGFnZSBpbmRleCBmb3IgbGFyZ2UgaHdwb2lzb24gKi8KIAotI2RlZmluZSBWTV9GQVVMVF9FUlJPUgkoVk1fRkFVTFRfT09NIHwgVk1fRkFVTFRfU0lHQlVTIHwgVk1fRkFVTFRfSFdQT0lTT04gfCBcCi0JCQkgVk1fRkFVTFRfRkFMTEJBQ0sgfCBWTV9GQVVMVF9IV1BPSVNPTl9MQVJHRSkKKyNkZWZpbmUgVk1fRkFVTFRfRVJST1IJKFZNX0ZBVUxUX09PTSB8IFZNX0ZBVUxUX1NJR0JVUyB8IFZNX0ZBVUxUX1NJR1NFR1YgfCBcCisJCQkgVk1fRkFVTFRfSFdQT0lTT04gfCBWTV9GQVVMVF9IV1BPSVNPTl9MQVJHRSB8IFwKKwkJCSBWTV9GQVVMVF9GQUxMQkFDSykKIAogLyogRW5jb2RlIGhzdGF0ZSBpbmRleCBmb3IgYSBod3BvaXNvbmVkIGxhcmdlIHBhZ2UgKi8KICNkZWZpbmUgVk1fRkFVTFRfU0VUX0hJTkRFWCh4KSAoKHgpIDw8IDEyKQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9tb2R1bGUuaCBiL2luY2x1ZGUvbGludXgvbW9kdWxlLmgKaW5kZXggZWJmYjBlMS4uYjY1M2Q3YyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9tb2R1bGUuaAorKysgYi9pbmNsdWRlL2xpbnV4L21vZHVsZS5oCkBAIC00NDQsNyArNDQ0LDcgQEAKICNkZWZpbmUgbW9kdWxlX3B1dF9hbmRfZXhpdChjb2RlKSBfX21vZHVsZV9wdXRfYW5kX2V4aXQoVEhJU19NT0RVTEUsIGNvZGUpCiAKICNpZmRlZiBDT05GSUdfTU9EVUxFX1VOTE9BRAotdW5zaWduZWQgbG9uZyBtb2R1bGVfcmVmY291bnQoc3RydWN0IG1vZHVsZSAqbW9kKTsKK2ludCBtb2R1bGVfcmVmY291bnQoc3RydWN0IG1vZHVsZSAqbW9kKTsKIHZvaWQgX19zeW1ib2xfcHV0KGNvbnN0IGNoYXIgKnN5bWJvbCk7CiAjZGVmaW5lIHN5bWJvbF9wdXQoeCkgX19zeW1ib2xfcHV0KFZNTElOVVhfU1lNQk9MX1NUUih4KSkKIHZvaWQgc3ltYm9sX3B1dF9hZGRyKHZvaWQgKmFkZHIpOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9tb2R1bGVsb2FkZXIuaCBiL2luY2x1ZGUvbGludXgvbW9kdWxlbG9hZGVyLmgKaW5kZXggN2VlYjliYi4uZjc1NTYyNiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9tb2R1bGVsb2FkZXIuaAorKysgYi9pbmNsdWRlL2xpbnV4L21vZHVsZWxvYWRlci5oCkBAIC0yNiw3ICsyNiw3IEBACiB2b2lkICptb2R1bGVfYWxsb2ModW5zaWduZWQgbG9uZyBzaXplKTsKIAogLyogRnJlZSBtZW1vcnkgcmV0dXJuZWQgZnJvbSBtb2R1bGVfYWxsb2MuICovCi12b2lkIG1vZHVsZV9mcmVlKHN0cnVjdCBtb2R1bGUgKm1vZCwgdm9pZCAqbW9kdWxlX3JlZ2lvbik7Cit2b2lkIG1vZHVsZV9tZW1mcmVlKHZvaWQgKm1vZHVsZV9yZWdpb24pOwogCiAvKgogICogQXBwbHkgdGhlIGdpdmVuIHJlbG9jYXRpb24gdG8gdGhlIChzaW1wbGlmaWVkKSBFTEYuICBSZXR1cm4gLWVycm9yCkBAIC04Miw0ICs4Miw2IEBACiAvKiBBbnkgY2xlYW51cCBuZWVkZWQgd2hlbiBtb2R1bGUgbGVhdmVzLiAqLwogdm9pZCBtb2R1bGVfYXJjaF9jbGVhbnVwKHN0cnVjdCBtb2R1bGUgKm1vZCk7CiAKKy8qIEFueSBjbGVhbnVwIGJlZm9yZSBmcmVlaW5nIG1vZC0+bW9kdWxlX2luaXQgKi8KK3ZvaWQgbW9kdWxlX2FyY2hfZnJlZWluZ19pbml0KHN0cnVjdCBtb2R1bGUgKm1vZCk7CiAjZW5kaWYKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvb29tLmggYi9pbmNsdWRlL2xpbnV4L29vbS5oCmluZGV4IDg1MzY5OGMuLjc2MjAwOTggMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvb29tLmgKKysrIGIvaW5jbHVkZS9saW51eC9vb20uaApAQCAtODUsMTEgKzg1LDYgQEAKIAlvb21fa2lsbGVyX2Rpc2FibGVkID0gZmFsc2U7CiB9CiAKLXN0YXRpYyBpbmxpbmUgYm9vbCBvb21fZ2ZwX2FsbG93ZWQoZ2ZwX3QgZ2ZwX21hc2spCi17Ci0JcmV0dXJuIChnZnBfbWFzayAmIF9fR0ZQX0ZTKSAmJiAhKGdmcF9tYXNrICYgX19HRlBfTk9SRVRSWSk7Ci19Ci0KIGV4dGVybiBzdHJ1Y3QgdGFza19zdHJ1Y3QgKmZpbmRfbG9ja190YXNrX21tKHN0cnVjdCB0YXNrX3N0cnVjdCAqcCk7CiAKIHN0YXRpYyBpbmxpbmUgYm9vbCB0YXNrX3dpbGxfZnJlZV9tZW0oc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrKQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9wY2kuaCBiL2luY2x1ZGUvbGludXgvcGNpLmgKaW5kZXggMzYwYTk2Ni4uZmFhNjBmYSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9wY2kuaAorKysgYi9pbmNsdWRlL2xpbnV4L3BjaS5oCkBAIC0yOSw2ICsyOSw3IEBACiAjaW5jbHVkZSA8bGludXgvYXRvbWljLmg+CiAjaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+CiAjaW5jbHVkZSA8bGludXgvaW8uaD4KKyNpbmNsdWRlIDxsaW51eC9yZXNvdXJjZV9leHQuaD4KICNpbmNsdWRlIDx1YXBpL2xpbnV4L3BjaS5oPgogCiAjaW5jbHVkZSA8bGludXgvcGNpX2lkcy5oPgpAQCAtMTc1LDYgKzE3Niw4IEBACiAJUENJX0RFVl9GTEFHU19ETUFfQUxJQVNfREVWRk4gPSAoX19mb3JjZSBwY2lfZGV2X2ZsYWdzX3QpICgxIDw8IDQpLAogCS8qIFVzZSBhIFBDSWUtdG8tUENJIGJyaWRnZSBhbGlhcyBldmVuIGlmICFwY2lfaXNfcGNpZSAqLwogCVBDSV9ERVZfRkxBR19QQ0lFX0JSSURHRV9BTElBUyA9IChfX2ZvcmNlIHBjaV9kZXZfZmxhZ3NfdCkgKDEgPDwgNSksCisJLyogRG8gbm90IHVzZSBidXMgcmVzZXRzIGZvciBkZXZpY2UgKi8KKwlQQ0lfREVWX0ZMQUdTX05PX0JVU19SRVNFVCA9IChfX2ZvcmNlIHBjaV9kZXZfZmxhZ3NfdCkgKDEgPDwgNiksCiB9OwogCiBlbnVtIHBjaV9pcnFfcmVyb3V0ZV92YXJpYW50IHsKQEAgLTM5NSwxNiArMzk4LDEwIEBACiAJcmV0dXJuIChwZGV2LT5lcnJvcl9zdGF0ZSAhPSBwY2lfY2hhbm5lbF9pb19ub3JtYWwpOwogfQogCi1zdHJ1Y3QgcGNpX2hvc3RfYnJpZGdlX3dpbmRvdyB7Ci0Jc3RydWN0IGxpc3RfaGVhZCBsaXN0OwotCXN0cnVjdCByZXNvdXJjZSAqcmVzOwkJLyogaG9zdCBicmlkZ2UgYXBlcnR1cmUgKENQVSBhZGRyZXNzKSAqLwotCXJlc291cmNlX3NpemVfdCBvZmZzZXQ7CQkvKiBidXMgYWRkcmVzcyArIG9mZnNldCA9IENQVSBhZGRyZXNzICovCi19OwotCiBzdHJ1Y3QgcGNpX2hvc3RfYnJpZGdlIHsKIAlzdHJ1Y3QgZGV2aWNlIGRldjsKIAlzdHJ1Y3QgcGNpX2J1cyAqYnVzOwkJLyogcm9vdCBidXMgKi8KLQlzdHJ1Y3QgbGlzdF9oZWFkIHdpbmRvd3M7CS8qIHBjaV9ob3N0X2JyaWRnZV93aW5kb3dzICovCisJc3RydWN0IGxpc3RfaGVhZCB3aW5kb3dzOwkvKiByZXNvdXJjZV9lbnRyeSAqLwogCXZvaWQgKCpyZWxlYXNlX2ZuKShzdHJ1Y3QgcGNpX2hvc3RfYnJpZGdlICopOwogCXZvaWQgKnJlbGVhc2VfZGF0YTsKIH07CkBAIC0xMDY1LDYgKzEwNjIsNyBAQAogdm9pZCBwY2lfYnVzX2Fzc2lnbl9yZXNvdXJjZXMoY29uc3Qgc3RydWN0IHBjaV9idXMgKmJ1cyk7CiB2b2lkIHBjaV9idXNfc2l6ZV9icmlkZ2VzKHN0cnVjdCBwY2lfYnVzICpidXMpOwogaW50IHBjaV9jbGFpbV9yZXNvdXJjZShzdHJ1Y3QgcGNpX2RldiAqLCBpbnQpOworaW50IHBjaV9jbGFpbV9icmlkZ2VfcmVzb3VyY2Uoc3RydWN0IHBjaV9kZXYgKmJyaWRnZSwgaW50IGkpOwogdm9pZCBwY2lfYXNzaWduX3VuYXNzaWduZWRfcmVzb3VyY2VzKHZvaWQpOwogdm9pZCBwY2lfYXNzaWduX3VuYXNzaWduZWRfYnJpZGdlX3Jlc291cmNlcyhzdHJ1Y3QgcGNpX2RldiAqYnJpZGdlKTsKIHZvaWQgcGNpX2Fzc2lnbl91bmFzc2lnbmVkX2J1c19yZXNvdXJjZXMoc3RydWN0IHBjaV9idXMgKmJ1cyk7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3BlcmZfZXZlbnQuaCBiL2luY2x1ZGUvbGludXgvcGVyZl9ldmVudC5oCmluZGV4IDRmN2E2MWMuLjY2NGRlNWEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvcGVyZl9ldmVudC5oCisrKyBiL2luY2x1ZGUvbGludXgvcGVyZl9ldmVudC5oCkBAIC00NTAsMTEgKzQ1MCw2IEBACiAjZW5kaWYgLyogQ09ORklHX1BFUkZfRVZFTlRTICovCiB9OwogCi1lbnVtIHBlcmZfZXZlbnRfY29udGV4dF90eXBlIHsKLQl0YXNrX2NvbnRleHQsCi0JY3B1X2NvbnRleHQsCi19OwotCiAvKioKICAqIHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgLSBldmVudCBjb250ZXh0IHN0cnVjdHVyZQogICoKQEAgLTQ2Miw3ICs0NTcsNiBAQAogICovCiBzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0IHsKIAlzdHJ1Y3QgcG11CQkJKnBtdTsKLQllbnVtIHBlcmZfZXZlbnRfY29udGV4dF90eXBlCXR5cGU7CiAJLyoKIAkgKiBQcm90ZWN0IHRoZSBzdGF0ZXMgb2YgdGhlIGV2ZW50cyBpbiB0aGUgbGlzdCwKIAkgKiBucl9hY3RpdmUsIGFuZCB0aGUgbGlzdDoKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvcG0uaCBiL2luY2x1ZGUvbGludXgvcG0uaAppbmRleCA4YjU5NzYzLi5lMmYxYmU2IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3BtLmgKKysrIGIvaW5jbHVkZS9saW51eC9wbS5oCkBAIC01OTcsNyArNTk3LDcgQEAKIAogZXh0ZXJuIHZvaWQgdXBkYXRlX3BtX3J1bnRpbWVfYWNjb3VudGluZyhzdHJ1Y3QgZGV2aWNlICpkZXYpOwogZXh0ZXJuIGludCBkZXZfcG1fZ2V0X3N1YnN5c19kYXRhKHN0cnVjdCBkZXZpY2UgKmRldik7Ci1leHRlcm4gaW50IGRldl9wbV9wdXRfc3Vic3lzX2RhdGEoc3RydWN0IGRldmljZSAqZGV2KTsKK2V4dGVybiB2b2lkIGRldl9wbV9wdXRfc3Vic3lzX2RhdGEoc3RydWN0IGRldmljZSAqZGV2KTsKIAogLyoKICAqIFBvd2VyIGRvbWFpbnMgcHJvdmlkZSBjYWxsYmFja3MgdGhhdCBhcmUgZXhlY3V0ZWQgZHVyaW5nIHN5c3RlbSBzdXNwZW5kLApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9wbV9kb21haW4uaCBiL2luY2x1ZGUvbGludXgvcG1fZG9tYWluLmgKaW5kZXggYTllZGFiMi4uMDgwZTc3OCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9wbV9kb21haW4uaAorKysgYi9pbmNsdWRlL2xpbnV4L3BtX2RvbWFpbi5oCkBAIC0xMTMsOCArMTEzLDYgQEAKIAlzdHJ1Y3QgcG1fZG9tYWluX2RhdGEgYmFzZTsKIAlzdHJ1Y3QgZ3BkX3RpbWluZ19kYXRhIHRkOwogCXN0cnVjdCBub3RpZmllcl9ibG9jayBuYjsKLQlzdHJ1Y3QgbXV0ZXggbG9jazsKLQl1bnNpZ25lZCBpbnQgcmVmY291bnQ7CiAJaW50IG5lZWRfcmVzdG9yZTsKIH07CiAKQEAgLTE0MCw3ICsxMzgsNiBAQAogCiBleHRlcm4gaW50IHBtX2dlbnBkX3JlbW92ZV9kZXZpY2Uoc3RydWN0IGdlbmVyaWNfcG1fZG9tYWluICpnZW5wZCwKIAkJCQkgIHN0cnVjdCBkZXZpY2UgKmRldik7Ci1leHRlcm4gdm9pZCBwbV9nZW5wZF9kZXZfbmVlZF9yZXN0b3JlKHN0cnVjdCBkZXZpY2UgKmRldiwgYm9vbCB2YWwpOwogZXh0ZXJuIGludCBwbV9nZW5wZF9hZGRfc3ViZG9tYWluKHN0cnVjdCBnZW5lcmljX3BtX2RvbWFpbiAqZ2VucGQsCiAJCQkJICBzdHJ1Y3QgZ2VuZXJpY19wbV9kb21haW4gKm5ld19zdWJkb21haW4pOwogZXh0ZXJuIGludCBwbV9nZW5wZF9hZGRfc3ViZG9tYWluX25hbWVzKGNvbnN0IGNoYXIgKm1hc3Rlcl9uYW1lLApAQCAtMTg3LDcgKzE4NCw2IEBACiB7CiAJcmV0dXJuIC1FTk9TWVM7CiB9Ci1zdGF0aWMgaW5saW5lIHZvaWQgcG1fZ2VucGRfZGV2X25lZWRfcmVzdG9yZShzdHJ1Y3QgZGV2aWNlICpkZXYsIGJvb2wgdmFsKSB7fQogc3RhdGljIGlubGluZSBpbnQgcG1fZ2VucGRfYWRkX3N1YmRvbWFpbihzdHJ1Y3QgZ2VuZXJpY19wbV9kb21haW4gKmdlbnBkLAogCQkJCQkgc3RydWN0IGdlbmVyaWNfcG1fZG9tYWluICpuZXdfc2QpCiB7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3ByaW50ay5oIGIvaW5jbHVkZS9saW51eC9wcmludGsuaAppbmRleCBjOGYxNzAzLi40ZDViZjU3IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3ByaW50ay5oCisrKyBiL2luY2x1ZGUvbGludXgvcHJpbnRrLmgKQEAgLTEwLDkgKzEwLDYgQEAKIGV4dGVybiBjb25zdCBjaGFyIGxpbnV4X2Jhbm5lcltdOwogZXh0ZXJuIGNvbnN0IGNoYXIgbGludXhfcHJvY19iYW5uZXJbXTsKIAotZXh0ZXJuIGNoYXIgKmxvZ19idWZfYWRkcl9nZXQodm9pZCk7Ci1leHRlcm4gdTMyIGxvZ19idWZfbGVuX2dldCh2b2lkKTsKLQogc3RhdGljIGlubGluZSBpbnQgcHJpbnRrX2dldF9sZXZlbChjb25zdCBjaGFyICpidWZmZXIpCiB7CiAJaWYgKGJ1ZmZlclswXSA9PSBLRVJOX1NPSF9BU0NJSSAmJiBidWZmZXJbMV0pIHsKQEAgLTE2Myw2ICsxNjAsOCBAQAogCiBleHRlcm4gdm9pZCB3YWtlX3VwX2tsb2dkKHZvaWQpOwogCitjaGFyICpsb2dfYnVmX2FkZHJfZ2V0KHZvaWQpOwordTMyIGxvZ19idWZfbGVuX2dldCh2b2lkKTsKIHZvaWQgbG9nX2J1Zl9rZXhlY19zZXR1cCh2b2lkKTsKIHZvaWQgX19pbml0IHNldHVwX2xvZ19idWYoaW50IGVhcmx5KTsKIHZvaWQgZHVtcF9zdGFja19zZXRfYXJjaF9kZXNjKGNvbnN0IGNoYXIgKmZtdCwgLi4uKTsKQEAgLTE5OCw2ICsxOTcsMTYgQEAKIHsKIH0KIAorc3RhdGljIGlubGluZSBjaGFyICpsb2dfYnVmX2FkZHJfZ2V0KHZvaWQpCit7CisJcmV0dXJuIE5VTEw7Cit9CisKK3N0YXRpYyBpbmxpbmUgdTMyIGxvZ19idWZfbGVuX2dldCh2b2lkKQoreworCXJldHVybiAwOworfQorCiBzdGF0aWMgaW5saW5lIHZvaWQgbG9nX2J1Zl9rZXhlY19zZXR1cCh2b2lkKQogewogfQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9xdW90YS5oIGIvaW5jbHVkZS9saW51eC9xdW90YS5oCmluZGV4IDUwOTc4YjcuLjA5N2Q3ZWIyIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3F1b3RhLmgKKysrIGIvaW5jbHVkZS9saW51eC9xdW90YS5oCkBAIC0zMjEsNiArMzIxLDQ5IEBACiAKIHN0cnVjdCBwYXRoOwogCisvKiBTdHJ1Y3R1cmUgZm9yIGNvbW11bmljYXRpbmcgdmlhIC0+Z2V0X2RxYmxrKCkgJiAtPnNldF9kcWJsaygpICovCitzdHJ1Y3QgcWNfZHFibGsgeworCWludCBkX2ZpZWxkbWFzazsJLyogbWFzayBvZiBmaWVsZHMgdG8gY2hhbmdlIGluIC0+c2V0X2RxYmxrKCkgKi8KKwl1NjQgZF9zcGNfaGFyZGxpbWl0OwkvKiBhYnNvbHV0ZSBsaW1pdCBvbiB1c2VkIHNwYWNlICovCisJdTY0IGRfc3BjX3NvZnRsaW1pdDsJLyogcHJlZmVycmVkIGxpbWl0IG9uIHVzZWQgc3BhY2UgKi8KKwl1NjQgZF9pbm9faGFyZGxpbWl0OwkvKiBtYXhpbXVtICMgYWxsb2NhdGVkIGlub2RlcyAqLworCXU2NCBkX2lub19zb2Z0bGltaXQ7CS8qIHByZWZlcnJlZCBpbm9kZSBsaW1pdCAqLworCXU2NCBkX3NwYWNlOwkJLyogU3BhY2Ugb3duZWQgYnkgdGhlIHVzZXIgKi8KKwl1NjQgZF9pbm9fY291bnQ7CS8qICMgaW5vZGVzIG93bmVkIGJ5IHRoZSB1c2VyICovCisJczY0IGRfaW5vX3RpbWVyOwkvKiB6ZXJvIGlmIHdpdGhpbiBpbm9kZSBsaW1pdHMgKi8KKwkJCQkvKiBpZiBub3QsIHdlIHJlZnVzZSBzZXJ2aWNlICovCisJczY0IGRfc3BjX3RpbWVyOwkvKiBzaW1pbGFyIHRvIGFib3ZlOyBmb3Igc3BhY2UgKi8KKwlpbnQgZF9pbm9fd2FybnM7CS8qICMgd2FybmluZ3MgaXNzdWVkIHdydCBudW0gaW5vZGVzICovCisJaW50IGRfc3BjX3dhcm5zOwkvKiAjIHdhcm5pbmdzIGlzc3VlZCB3cnQgdXNlZCBzcGFjZSAqLworCXU2NCBkX3J0X3NwY19oYXJkbGltaXQ7CS8qIGFic29sdXRlIGxpbWl0IG9uIHJlYWx0aW1lIHNwYWNlICovCisJdTY0IGRfcnRfc3BjX3NvZnRsaW1pdDsJLyogcHJlZmVycmVkIGxpbWl0IG9uIFJUIHNwYWNlICovCisJdTY0IGRfcnRfc3BhY2U7CQkvKiByZWFsdGltZSBzcGFjZSBvd25lZCAqLworCXM2NCBkX3J0X3NwY190aW1lcjsJLyogc2ltaWxhciB0byBhYm92ZTsgZm9yIFJUIHNwYWNlICovCisJaW50IGRfcnRfc3BjX3dhcm5zOwkvKiAjIHdhcm5pbmdzIGlzc3VlZCB3cnQgUlQgc3BhY2UgKi8KK307CisKKy8qIEZpZWxkIHNwZWNpZmllcnMgZm9yIC0+c2V0X2RxYmxrKCkgaW4gc3RydWN0IHFjX2RxYmxrICovCisjZGVmaW5lCVFDX0lOT19TT0ZUCSgxPDwwKQorI2RlZmluZQlRQ19JTk9fSEFSRAkoMTw8MSkKKyNkZWZpbmUJUUNfU1BDX1NPRlQJKDE8PDIpCisjZGVmaW5lCVFDX1NQQ19IQVJECSgxPDwzKQorI2RlZmluZQlRQ19SVF9TUENfU09GVAkoMTw8NCkKKyNkZWZpbmUJUUNfUlRfU1BDX0hBUkQJKDE8PDUpCisjZGVmaW5lIFFDX0xJTUlUX01BU0sgKFFDX0lOT19TT0ZUIHwgUUNfSU5PX0hBUkQgfCBRQ19TUENfU09GVCB8IFFDX1NQQ19IQVJEIHwgXAorCQkgICAgICAgUUNfUlRfU1BDX1NPRlQgfCBRQ19SVF9TUENfSEFSRCkKKyNkZWZpbmUJUUNfU1BDX1RJTUVSCSgxPDw2KQorI2RlZmluZQlRQ19JTk9fVElNRVIJKDE8PDcpCisjZGVmaW5lCVFDX1JUX1NQQ19USU1FUgkoMTw8OCkKKyNkZWZpbmUgUUNfVElNRVJfTUFTSyAoUUNfU1BDX1RJTUVSIHwgUUNfSU5PX1RJTUVSIHwgUUNfUlRfU1BDX1RJTUVSKQorI2RlZmluZQlRQ19TUENfV0FSTlMJKDE8PDkpCisjZGVmaW5lCVFDX0lOT19XQVJOUwkoMTw8MTApCisjZGVmaW5lCVFDX1JUX1NQQ19XQVJOUwkoMTw8MTEpCisjZGVmaW5lIFFDX1dBUk5TX01BU0sgKFFDX1NQQ19XQVJOUyB8IFFDX0lOT19XQVJOUyB8IFFDX1JUX1NQQ19XQVJOUykKKyNkZWZpbmUJUUNfU1BBQ0UJKDE8PDEyKQorI2RlZmluZQlRQ19JTk9fQ09VTlQJKDE8PDEzKQorI2RlZmluZQlRQ19SVF9TUEFDRQkoMTw8MTQpCisjZGVmaW5lIFFDX0FDQ1RfTUFTSyAoUUNfU1BBQ0UgfCBRQ19JTk9fQ09VTlQgfCBRQ19SVF9TUEFDRSkKKwogLyogT3BlcmF0aW9ucyBoYW5kbGluZyByZXF1ZXN0cyBmcm9tIHVzZXJzcGFjZSAqLwogc3RydWN0IHF1b3RhY3RsX29wcyB7CiAJaW50ICgqcXVvdGFfb24pKHN0cnVjdCBzdXBlcl9ibG9jayAqLCBpbnQsIGludCwgc3RydWN0IHBhdGggKik7CkBAIC0zMjksOCArMzcyLDggQEAKIAlpbnQgKCpxdW90YV9zeW5jKShzdHJ1Y3Qgc3VwZXJfYmxvY2sgKiwgaW50KTsKIAlpbnQgKCpnZXRfaW5mbykoc3RydWN0IHN1cGVyX2Jsb2NrICosIGludCwgc3RydWN0IGlmX2RxaW5mbyAqKTsKIAlpbnQgKCpzZXRfaW5mbykoc3RydWN0IHN1cGVyX2Jsb2NrICosIGludCwgc3RydWN0IGlmX2RxaW5mbyAqKTsKLQlpbnQgKCpnZXRfZHFibGspKHN0cnVjdCBzdXBlcl9ibG9jayAqLCBzdHJ1Y3Qga3FpZCwgc3RydWN0IGZzX2Rpc2tfcXVvdGEgKik7Ci0JaW50ICgqc2V0X2RxYmxrKShzdHJ1Y3Qgc3VwZXJfYmxvY2sgKiwgc3RydWN0IGtxaWQsIHN0cnVjdCBmc19kaXNrX3F1b3RhICopOworCWludCAoKmdldF9kcWJsaykoc3RydWN0IHN1cGVyX2Jsb2NrICosIHN0cnVjdCBrcWlkLCBzdHJ1Y3QgcWNfZHFibGsgKik7CisJaW50ICgqc2V0X2RxYmxrKShzdHJ1Y3Qgc3VwZXJfYmxvY2sgKiwgc3RydWN0IGtxaWQsIHN0cnVjdCBxY19kcWJsayAqKTsKIAlpbnQgKCpnZXRfeHN0YXRlKShzdHJ1Y3Qgc3VwZXJfYmxvY2sgKiwgc3RydWN0IGZzX3F1b3RhX3N0YXQgKik7CiAJaW50ICgqc2V0X3hzdGF0ZSkoc3RydWN0IHN1cGVyX2Jsb2NrICosIHVuc2lnbmVkIGludCwgaW50KTsKIAlpbnQgKCpnZXRfeHN0YXRldikoc3RydWN0IHN1cGVyX2Jsb2NrICosIHN0cnVjdCBmc19xdW90YV9zdGF0diAqKTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvcXVvdGFvcHMuaCBiL2luY2x1ZGUvbGludXgvcXVvdGFvcHMuaAppbmRleCBmMjM1MzhhLi4yOWUzNDU1IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3F1b3Rhb3BzLmgKKysrIGIvaW5jbHVkZS9saW51eC9xdW90YW9wcy5oCkBAIC05OCw5ICs5OCw5IEBACiBpbnQgZHF1b3RfZ2V0X2RxaW5mbyhzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCBpbnQgdHlwZSwgc3RydWN0IGlmX2RxaW5mbyAqaWkpOwogaW50IGRxdW90X3NldF9kcWluZm8oc3RydWN0IHN1cGVyX2Jsb2NrICpzYiwgaW50IHR5cGUsIHN0cnVjdCBpZl9kcWluZm8gKmlpKTsKIGludCBkcXVvdF9nZXRfZHFibGsoc3RydWN0IHN1cGVyX2Jsb2NrICpzYiwgc3RydWN0IGtxaWQgaWQsCi0JCXN0cnVjdCBmc19kaXNrX3F1b3RhICpkaSk7CisJCXN0cnVjdCBxY19kcWJsayAqZGkpOwogaW50IGRxdW90X3NldF9kcWJsayhzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCBzdHJ1Y3Qga3FpZCBpZCwKLQkJc3RydWN0IGZzX2Rpc2tfcXVvdGEgKmRpKTsKKwkJc3RydWN0IHFjX2RxYmxrICpkaSk7CiAKIGludCBfX2RxdW90X3RyYW5zZmVyKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBkcXVvdCAqKnRyYW5zZmVyX3RvKTsKIGludCBkcXVvdF90cmFuc2ZlcihzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgaWF0dHIgKmlhdHRyKTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvcmVzb3VyY2VfZXh0LmggYi9pbmNsdWRlL2xpbnV4L3Jlc291cmNlX2V4dC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmUyYmY2M2QKLS0tIC9kZXYvbnVsbAorKysgYi9pbmNsdWRlL2xpbnV4L3Jlc291cmNlX2V4dC5oCkBAIC0wLDAgKzEsNzcgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTUsIEludGVsIENvcnBvcmF0aW9uCisgKiBBdXRob3I6IEppYW5nIExpdSA8amlhbmcubGl1QGxpbnV4LmludGVsLmNvbT4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSwKKyAqIHZlcnNpb24gMiwgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIGl0IHdpbGwgYmUgdXNlZnVsLCBidXQgV0lUSE9VVAorICogQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yCisgKiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yCisgKiBtb3JlIGRldGFpbHMuCisgKi8KKyNpZm5kZWYgX0xJTlVYX1JFU09VUkNFX0VYVF9ICisjZGVmaW5lIF9MSU5VWF9SRVNPVVJDRV9FWFRfSAorI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CisjaW5jbHVkZSA8bGludXgvbGlzdC5oPgorI2luY2x1ZGUgPGxpbnV4L2lvcG9ydC5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKworLyogUmVwcmVzZW50IHJlc291cmNlIHdpbmRvdyBmb3IgYnJpZGdlIGRldmljZXMgKi8KK3N0cnVjdCByZXNvdXJjZV93aW4geworCXN0cnVjdCByZXNvdXJjZSByZXM7CQkvKiBJbiBtYXN0ZXIgKENQVSkgYWRkcmVzcyBzcGFjZSAqLworCXJlc291cmNlX3NpemVfdCBvZmZzZXQ7CQkvKiBUcmFuc2xhdGlvbiBvZmZzZXQgZm9yIGJyaWRnZSAqLworfTsKKworLyoKKyAqIENvbW1vbiByZXNvdXJjZSBsaXN0IG1hbmFnZW1lbnQgZGF0YSBzdHJ1Y3R1cmUgYW5kIGludGVyZmFjZXMgdG8gc3VwcG9ydAorICogQUNQSSwgUE5QIGFuZCBQQ0kgaG9zdCBicmlkZ2UgZXRjLgorICovCitzdHJ1Y3QgcmVzb3VyY2VfZW50cnkgeworCXN0cnVjdCBsaXN0X2hlYWQJbm9kZTsKKwlzdHJ1Y3QgcmVzb3VyY2UJCSpyZXM7CS8qIEluIG1hc3RlciAoQ1BVKSBhZGRyZXNzIHNwYWNlICovCisJcmVzb3VyY2Vfc2l6ZV90CQlvZmZzZXQ7CS8qIFRyYW5zbGF0aW9uIG9mZnNldCBmb3IgYnJpZGdlICovCisJc3RydWN0IHJlc291cmNlCQlfX3JlczsJLyogRGVmYXVsdCBzdG9yYWdlIGZvciByZXMgKi8KK307CisKK2V4dGVybiBzdHJ1Y3QgcmVzb3VyY2VfZW50cnkgKgorcmVzb3VyY2VfbGlzdF9jcmVhdGVfZW50cnkoc3RydWN0IHJlc291cmNlICpyZXMsIHNpemVfdCBleHRyYV9zaXplKTsKK2V4dGVybiB2b2lkIHJlc291cmNlX2xpc3RfZnJlZShzdHJ1Y3QgbGlzdF9oZWFkICpoZWFkKTsKKworc3RhdGljIGlubGluZSB2b2lkIHJlc291cmNlX2xpc3RfYWRkKHN0cnVjdCByZXNvdXJjZV9lbnRyeSAqZW50cnksCisJCQkJICAgICBzdHJ1Y3QgbGlzdF9oZWFkICpoZWFkKQoreworCWxpc3RfYWRkKCZlbnRyeS0+bm9kZSwgaGVhZCk7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCByZXNvdXJjZV9saXN0X2FkZF90YWlsKHN0cnVjdCByZXNvdXJjZV9lbnRyeSAqZW50cnksCisJCQkJCSAgc3RydWN0IGxpc3RfaGVhZCAqaGVhZCkKK3sKKwlsaXN0X2FkZF90YWlsKCZlbnRyeS0+bm9kZSwgaGVhZCk7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCByZXNvdXJjZV9saXN0X2RlbChzdHJ1Y3QgcmVzb3VyY2VfZW50cnkgKmVudHJ5KQoreworCWxpc3RfZGVsKCZlbnRyeS0+bm9kZSk7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCByZXNvdXJjZV9saXN0X2ZyZWVfZW50cnkoc3RydWN0IHJlc291cmNlX2VudHJ5ICplbnRyeSkKK3sKKwlrZnJlZShlbnRyeSk7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZAorcmVzb3VyY2VfbGlzdF9kZXN0cm95X2VudHJ5KHN0cnVjdCByZXNvdXJjZV9lbnRyeSAqZW50cnkpCit7CisJcmVzb3VyY2VfbGlzdF9kZWwoZW50cnkpOworCXJlc291cmNlX2xpc3RfZnJlZV9lbnRyeShlbnRyeSk7Cit9CisKKyNkZWZpbmUgcmVzb3VyY2VfbGlzdF9mb3JfZWFjaF9lbnRyeShlbnRyeSwgbGlzdCkJXAorCWxpc3RfZm9yX2VhY2hfZW50cnkoKGVudHJ5KSwgKGxpc3QpLCBub2RlKQorCisjZGVmaW5lIHJlc291cmNlX2xpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShlbnRyeSwgdG1wLCBsaXN0KQlcCisJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKChlbnRyeSksICh0bXApLCAobGlzdCksIG5vZGUpCisKKyNlbmRpZiAvKiBfTElOVVhfUkVTT1VSQ0VfRVhUX0ggKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvdGltZS5oIGIvaW5jbHVkZS9saW51eC90aW1lLmgKaW5kZXggMjAzYzJhZC4uYmVlYmUzYSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC90aW1lLmgKKysrIGIvaW5jbHVkZS9saW51eC90aW1lLmgKQEAgLTExMCw2ICsxMTAsMTkgQEAKIAlyZXR1cm4gdHJ1ZTsKIH0KIAorc3RhdGljIGlubGluZSBib29sIHRpbWV2YWxfdmFsaWQoY29uc3Qgc3RydWN0IHRpbWV2YWwgKnR2KQoreworCS8qIERhdGVzIGJlZm9yZSAxOTcwIGFyZSBib2d1cyAqLworCWlmICh0di0+dHZfc2VjIDwgMCkKKwkJcmV0dXJuIGZhbHNlOworCisJLyogQ2FuJ3QgaGF2ZSBtb3JlIG1pY3Jvc2Vjb25kcyB0aGVuIGEgc2Vjb25kICovCisJaWYgKHR2LT50dl91c2VjIDwgMCB8fCB0di0+dHZfdXNlYyA+PSBVU0VDX1BFUl9TRUMpCisJCXJldHVybiBmYWxzZTsKKworCXJldHVybiB0cnVlOworfQorCiBleHRlcm4gc3RydWN0IHRpbWVzcGVjIHRpbWVzcGVjX3RydW5jKHN0cnVjdCB0aW1lc3BlYyB0LCB1bnNpZ25lZCBncmFuKTsKIAogI2RlZmluZSBDVVJSRU5UX1RJTUUJCShjdXJyZW50X2tlcm5lbF90aW1lKCkpCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3RyYWNlcG9pbnQuaCBiL2luY2x1ZGUvbGludXgvdHJhY2Vwb2ludC5oCmluZGV4IGUwOGUyMWUuLmM3Mjg1MTMgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvdHJhY2Vwb2ludC5oCisrKyBiL2luY2x1ZGUvbGludXgvdHJhY2Vwb2ludC5oCkBAIC0xNzMsNyArMTczLDcgQEAKIAkJCQlUUF9QUk9UTyhkYXRhX3Byb3RvKSwJCQlcCiAJCQkJVFBfQVJHUyhkYXRhX2FyZ3MpLAkJCVwKIAkJCQlUUF9DT05ESVRJT04oY29uZCksLCk7CQkJXAotCQlpZiAoSVNfRU5BQkxFRChDT05GSUdfTE9DS0RFUCkpIHsJCQlcCisJCWlmIChJU19FTkFCTEVEKENPTkZJR19MT0NLREVQKSAmJiAoY29uZCkpIHsJCVwKIAkJCXJjdV9yZWFkX2xvY2tfc2NoZWRfbm90cmFjZSgpOwkJCVwKIAkJCXJjdV9kZXJlZmVyZW5jZV9zY2hlZChfX3RyYWNlcG9pbnRfIyNuYW1lLmZ1bmNzKTtcCiAJCQlyY3VfcmVhZF91bmxvY2tfc2NoZWRfbm90cmFjZSgpOwkJXApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC93YWl0LmggYi9pbmNsdWRlL2xpbnV4L3dhaXQuaAppbmRleCAyMjMyZWQxLi4zNzQyM2UwIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3dhaXQuaAorKysgYi9pbmNsdWRlL2xpbnV4L3dhaXQuaApAQCAtMzYzLDcgKzM2Myw2IEBACiAgKi8KICNkZWZpbmUgd2FpdF9ldmVudF9jbWQod3EsIGNvbmRpdGlvbiwgY21kMSwgY21kMikJCQlcCiBkbyB7CQkJCQkJCQkJXAotCW1pZ2h0X3NsZWVwKCk7CQkJCQkJCVwKIAlpZiAoY29uZGl0aW9uKQkJCQkJCQlcCiAJCWJyZWFrOwkJCQkJCQlcCiAJX193YWl0X2V2ZW50X2NtZCh3cSwgY29uZGl0aW9uLCBjbWQxLCBjbWQyKTsJCQlcCmRpZmYgLS1naXQgYS9pbmNsdWRlL25ldC9mbG93X2tleXMuaCBiL2luY2x1ZGUvbmV0L2Zsb3dfa2V5cy5oCmluZGV4IDdlZTJkZjAuLmRjOGZkODEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbmV0L2Zsb3dfa2V5cy5oCisrKyBiL2luY2x1ZGUvbmV0L2Zsb3dfa2V5cy5oCkBAIC0yMiw5ICsyMiw5IEBACiAJCV9fYmUzMiBwb3J0czsKIAkJX19iZTE2IHBvcnQxNlsyXTsKIAl9OwotCXUxNiB0aG9mZjsKLQl1MTYgbl9wcm90bzsKLQl1OCBpcF9wcm90bzsKKwl1MTYJdGhvZmY7CisJX19iZTE2CW5fcHJvdG87CisJdTgJaXBfcHJvdG87CiB9OwogCiBib29sIF9fc2tiX2Zsb3dfZGlzc2VjdChjb25zdCBzdHJ1Y3Qgc2tfYnVmZiAqc2tiLCBzdHJ1Y3QgZmxvd19rZXlzICpmbG93LApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9uZXQvZ2VuZXRsaW5rLmggYi9pbmNsdWRlL25ldC9nZW5ldGxpbmsuaAppbmRleCA4NDEyNTA4Li42YzkyNDE1IDEwMDY0NAotLS0gYS9pbmNsdWRlL25ldC9nZW5ldGxpbmsuaAorKysgYi9pbmNsdWRlL25ldC9nZW5ldGxpbmsuaApAQCAtMjcsMTMgKzI3LDE4IEBACiAgKiBAbWF4YXR0cjogbWF4aW11bSBudW1iZXIgb2YgYXR0cmlidXRlcyBzdXBwb3J0ZWQKICAqIEBuZXRuc29rOiBzZXQgdG8gdHJ1ZSBpZiB0aGUgZmFtaWx5IGNhbiBoYW5kbGUgbmV0d29yawogICoJbmFtZXNwYWNlcyBhbmQgc2hvdWxkIGJlIHByZXNlbnRlZCBpbiBhbGwgb2YgdGhlbQorICogQHBhcmFsbGVsX29wczogb3BlcmF0aW9ucyBjYW4gYmUgY2FsbGVkIGluIHBhcmFsbGVsIGFuZCBhcmVuJ3QKKyAqCXN5bmNocm9uaXplZCBieSB0aGUgY29yZSBnZW5ldGxpbmsgY29kZQogICogQHByZV9kb2l0OiBjYWxsZWQgYmVmb3JlIGFuIG9wZXJhdGlvbidzIGRvaXQgY2FsbGJhY2ssIGl0IG1heQogICoJZG8gYWRkaXRpb25hbCwgY29tbW9uLCBmaWx0ZXJpbmcgYW5kIHJldHVybiBhbiBlcnJvcgogICogQHBvc3RfZG9pdDogY2FsbGVkIGFmdGVyIGFuIG9wZXJhdGlvbidzIGRvaXQgY2FsbGJhY2ssIGl0IG1heQogICoJdW5kbyBvcGVyYXRpb25zIGRvbmUgYnkgcHJlX2RvaXQsIGZvciBleGFtcGxlIHJlbGVhc2UgbG9ja3MKICAqIEBtY2FzdF9iaW5kOiBhIHNvY2tldCBib3VuZCB0byB0aGUgZ2l2ZW4gbXVsdGljYXN0IGdyb3VwICh3aGljaAogICoJaXMgZ2l2ZW4gYXMgdGhlIG9mZnNldCBpbnRvIHRoZSBncm91cHMgYXJyYXkpCi0gKiBAbWNhc3RfdW5iaW5kOiBhIHNvY2tldCB3YXMgdW5ib3VuZCBmcm9tIHRoZSBnaXZlbiBtdWx0aWNhc3QgZ3JvdXAKKyAqIEBtY2FzdF91bmJpbmQ6IGEgc29ja2V0IHdhcyB1bmJvdW5kIGZyb20gdGhlIGdpdmVuIG11bHRpY2FzdCBncm91cC4KKyAqCU5vdGUgdGhhdCB1bmJpbmQoKSB3aWxsIG5vdCBiZSBjYWxsZWQgc3ltbWV0cmljYWxseSBpZiB0aGUKKyAqCWdlbmVyaWMgbmV0bGluayBmYW1pbHkgaXMgcmVtb3ZlZCB3aGlsZSB0aGVyZSBhcmUgc3RpbGwgb3BlbgorICoJc29ja2V0cy4KICAqIEBhdHRyYnVmOiBidWZmZXIgdG8gc3RvcmUgcGFyc2VkIGF0dHJpYnV0ZXMKICAqIEBmYW1pbHlfbGlzdDogZmFtaWx5IGxpc3QKICAqIEBtY2dycHM6IG11bHRpY2FzdCBncm91cHMgdXNlZCBieSB0aGlzIGZhbWlseSAocHJpdmF0ZSkKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbmV0L2lwLmggYi9pbmNsdWRlL25ldC9pcC5oCmluZGV4IDBiYjYyMDcuLjA5Y2Y1YWUgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbmV0L2lwLmgKKysrIGIvaW5jbHVkZS9uZXQvaXAuaApAQCAtMzksMTEgKzM5LDEyIEBACiAJc3RydWN0IGlwX29wdGlvbnMJb3B0OwkJLyogQ29tcGlsZWQgSVAgb3B0aW9ucwkJKi8KIAl1bnNpZ25lZCBjaGFyCQlmbGFnczsKIAotI2RlZmluZSBJUFNLQl9GT1JXQVJERUQJCTEKLSNkZWZpbmUgSVBTS0JfWEZSTV9UVU5ORUxfU0laRQkyCi0jZGVmaW5lIElQU0tCX1hGUk1fVFJBTlNGT1JNRUQJNAotI2RlZmluZSBJUFNLQl9GUkFHX0NPTVBMRVRFCTgKLSNkZWZpbmUgSVBTS0JfUkVST1VURUQJCTE2CisjZGVmaW5lIElQU0tCX0ZPUldBUkRFRAkJQklUKDApCisjZGVmaW5lIElQU0tCX1hGUk1fVFVOTkVMX1NJWkUJQklUKDEpCisjZGVmaW5lIElQU0tCX1hGUk1fVFJBTlNGT1JNRUQJQklUKDIpCisjZGVmaW5lIElQU0tCX0ZSQUdfQ09NUExFVEUJQklUKDMpCisjZGVmaW5lIElQU0tCX1JFUk9VVEVECQlCSVQoNCkKKyNkZWZpbmUgSVBTS0JfRE9SRURJUkVDVAlCSVQoNSkKIAogCXUxNgkJCWZyYWdfbWF4X3NpemU7CiB9OwpAQCAtMTgwLDcgKzE4MSw3IEBACiAJcmV0dXJuIChhcmctPmZsYWdzICYgSVBfUkVQTFlfQVJHX05PU1JDQ0hFQ0spID8gRkxPV0lfRkxBR19BTllTUkMgOiAwOwogfQogCi12b2lkIGlwX3NlbmRfdW5pY2FzdF9yZXBseShzdHJ1Y3QgbmV0ICpuZXQsIHN0cnVjdCBza19idWZmICpza2IsCit2b2lkIGlwX3NlbmRfdW5pY2FzdF9yZXBseShzdHJ1Y3Qgc29jayAqc2ssIHN0cnVjdCBza19idWZmICpza2IsCiAJCQkgICBjb25zdCBzdHJ1Y3QgaXBfb3B0aW9ucyAqc29wdCwKIAkJCSAgIF9fYmUzMiBkYWRkciwgX19iZTMyIHNhZGRyLAogCQkJICAgY29uc3Qgc3RydWN0IGlwX3JlcGx5X2FyZyAqYXJnLApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9uZXQvaXB2Ni5oIGIvaW5jbHVkZS9uZXQvaXB2Ni5oCmluZGV4IDQyOTI5MjkuLjZlNDE2ZjYgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbmV0L2lwdjYuaAorKysgYi9pbmNsdWRlL25ldC9pcHY2LmgKQEAgLTY3MSw2ICs2NzEsOSBAQAogCXJldHVybiBfX2lwdjZfYWRkcl9kaWZmKGExLCBhMiwgc2l6ZW9mKHN0cnVjdCBpbjZfYWRkcikpOwogfQogCit1MzIgX19pcHY2X3NlbGVjdF9pZGVudCh1MzIgaGFzaHJuZCwgc3RydWN0IGluNl9hZGRyICpkc3QsCisJCQlzdHJ1Y3QgaW42X2FkZHIgKnNyYyk7Cit2b2lkIGlwdjZfc2VsZWN0X2lkZW50KHN0cnVjdCBmcmFnX2hkciAqZmhkciwgc3RydWN0IHJ0Nl9pbmZvICpydCk7CiB2b2lkIGlwdjZfcHJveHlfc2VsZWN0X2lkZW50KHN0cnVjdCBza19idWZmICpza2IpOwogCiBpbnQgaXA2X2RzdF9ob3BsaW1pdChzdHJ1Y3QgZHN0X2VudHJ5ICpkc3QpOwpAQCAtNzA4LDcgKzcxMSw3IEBACiAJCQkJCV9fYmUzMiBmbG93bGFiZWwsIGJvb2wgYXV0b2xhYmVsKQogewogCWlmICghZmxvd2xhYmVsICYmIChhdXRvbGFiZWwgfHwgbmV0LT5pcHY2LnN5c2N0bC5hdXRvX2Zsb3dsYWJlbHMpKSB7Ci0JCV9fYmUzMiBoYXNoOworCQl1MzIgaGFzaDsKIAogCQloYXNoID0gc2tiX2dldF9oYXNoKHNrYik7CiAKQEAgLTcxOCw3ICs3MjEsNyBAQAogCQkgKi8KIAkJaGFzaCBePSBoYXNoID4+IDEyOwogCi0JCWZsb3dsYWJlbCA9IGhhc2ggJiBJUFY2X0ZMT1dMQUJFTF9NQVNLOworCQlmbG93bGFiZWwgPSAoX19mb3JjZSBfX2JlMzIpaGFzaCAmIElQVjZfRkxPV0xBQkVMX01BU0s7CiAJfQogCiAJcmV0dXJuIGZsb3dsYWJlbDsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbmV0L25ldGZpbHRlci9uZl90YWJsZXMuaCBiL2luY2x1ZGUvbmV0L25ldGZpbHRlci9uZl90YWJsZXMuaAppbmRleCAzYWU5NjllLi45ZWFhYTc4IDEwMDY0NAotLS0gYS9pbmNsdWRlL25ldC9uZXRmaWx0ZXIvbmZfdGFibGVzLmgKKysrIGIvaW5jbHVkZS9uZXQvbmV0ZmlsdGVyL25mX3RhYmxlcy5oCkBAIC01MzAsNiArNTMwLDggQEAKIAogaW50IG5mdF9jaGFpbl92YWxpZGF0ZV9kZXBlbmRlbmN5KGNvbnN0IHN0cnVjdCBuZnRfY2hhaW4gKmNoYWluLAogCQkJCSAgZW51bSBuZnRfY2hhaW5fdHlwZSB0eXBlKTsKK2ludCBuZnRfY2hhaW5fdmFsaWRhdGVfaG9va3MoY29uc3Qgc3RydWN0IG5mdF9jaGFpbiAqY2hhaW4sCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHVuc2lnbmVkIGludCBob29rX2ZsYWdzKTsKIAogc3RydWN0IG5mdF9zdGF0cyB7CiAJdTY0CQkJYnl0ZXM7CmRpZmYgLS1naXQgYS9pbmNsdWRlL25ldC9uZXRucy9pcHY0LmggYi9pbmNsdWRlL25ldC9uZXRucy9pcHY0LmgKaW5kZXggMjQ5NDVjZS4uMGZmZWYxYSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9uZXQvbmV0bnMvaXB2NC5oCisrKyBiL2luY2x1ZGUvbmV0L25ldG5zL2lwdjQuaApAQCAtNTIsNiArNTIsNyBAQAogCXN0cnVjdCBpbmV0X3BlZXJfYmFzZQkqcGVlcnM7CiAJc3RydWN0IHRjcG1faGFzaF9idWNrZXQJKnRjcF9tZXRyaWNzX2hhc2g7CiAJdW5zaWduZWQgaW50CQl0Y3BfbWV0cmljc19oYXNoX2xvZzsKKwlzdHJ1Y3Qgc29jayAgKiBfX3BlcmNwdQkqdGNwX3NrOwogCXN0cnVjdCBuZXRuc19mcmFncwlmcmFnczsKICNpZmRlZiBDT05GSUdfTkVURklMVEVSCiAJc3RydWN0IHh0X3RhYmxlCQkqaXB0YWJsZV9maWx0ZXI7CmRpZmYgLS1naXQgYS9pbmNsdWRlL25ldC9zY2hfZ2VuZXJpYy5oIGIvaW5jbHVkZS9uZXQvc2NoX2dlbmVyaWMuaAppbmRleCAzZDI4MmNiLi5jNjA1ZDMwIDEwMDY0NAotLS0gYS9pbmNsdWRlL25ldC9zY2hfZ2VuZXJpYy5oCisrKyBiL2luY2x1ZGUvbmV0L3NjaF9nZW5lcmljLmgKQEAgLTc5LDYgKzc5LDkgQEAKIAlzdHJ1Y3QgbmV0ZGV2X3F1ZXVlCSpkZXZfcXVldWU7CiAKIAlzdHJ1Y3QgZ25ldF9zdGF0c19yYXRlX2VzdDY0CXJhdGVfZXN0OworCXN0cnVjdCBnbmV0X3N0YXRzX2Jhc2ljX2NwdSBfX3BlcmNwdSAqY3B1X2JzdGF0czsKKwlzdHJ1Y3QgZ25ldF9zdGF0c19xdWV1ZQlfX3BlcmNwdSAqY3B1X3FzdGF0czsKKwogCXN0cnVjdCBRZGlzYwkJKm5leHRfc2NoZWQ7CiAJc3RydWN0IHNrX2J1ZmYJCSpnc29fc2tiOwogCS8qCkBAIC04NiwxNSArODksOSBAQAogCSAqLwogCXVuc2lnbmVkIGxvbmcJCXN0YXRlOwogCXN0cnVjdCBza19idWZmX2hlYWQJcTsKLQl1bmlvbiB7Ci0JCXN0cnVjdCBnbmV0X3N0YXRzX2Jhc2ljX3BhY2tlZCBic3RhdHM7Ci0JCXN0cnVjdCBnbmV0X3N0YXRzX2Jhc2ljX2NwdSBfX3BlcmNwdSAqY3B1X2JzdGF0czsKLQl9IF9fcGFja2VkOworCXN0cnVjdCBnbmV0X3N0YXRzX2Jhc2ljX3BhY2tlZCBic3RhdHM7CiAJdW5zaWduZWQgaW50CQlfX3N0YXRlOwotCXVuaW9uIHsKLQkJc3RydWN0IGduZXRfc3RhdHNfcXVldWUJcXN0YXRzOwotCQlzdHJ1Y3QgZ25ldF9zdGF0c19xdWV1ZQlfX3BlcmNwdSAqY3B1X3FzdGF0czsKLQl9IF9fcGFja2VkOworCXN0cnVjdCBnbmV0X3N0YXRzX3F1ZXVlCXFzdGF0czsKIAlzdHJ1Y3QgcmN1X2hlYWQJCXJjdV9oZWFkOwogCWludAkJCXBhZGRlZDsKIAlhdG9taWNfdAkJcmVmY250OwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9uZXQvdGNwLmggYi9pbmNsdWRlL25ldC90Y3AuaAppbmRleCBmNTBmMjlmYWYuLjlkOTExMWUgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbmV0L3RjcC5oCisrKyBiL2luY2x1ZGUvbmV0L3RjcC5oCkBAIC04MzQsOCArODM0LDggQEAKIHZvaWQgdGNwX2dldF9hbGxvd2VkX2Nvbmdlc3Rpb25fY29udHJvbChjaGFyICpidWYsIHNpemVfdCBsZW4pOwogaW50IHRjcF9zZXRfYWxsb3dlZF9jb25nZXN0aW9uX2NvbnRyb2woY2hhciAqYWxsb3dlZCk7CiBpbnQgdGNwX3NldF9jb25nZXN0aW9uX2NvbnRyb2woc3RydWN0IHNvY2sgKnNrLCBjb25zdCBjaGFyICpuYW1lKTsKLXZvaWQgdGNwX3Nsb3dfc3RhcnQoc3RydWN0IHRjcF9zb2NrICp0cCwgdTMyIGFja2VkKTsKLXZvaWQgdGNwX2NvbmdfYXZvaWRfYWkoc3RydWN0IHRjcF9zb2NrICp0cCwgdTMyIHcpOwordTMyIHRjcF9zbG93X3N0YXJ0KHN0cnVjdCB0Y3Bfc29jayAqdHAsIHUzMiBhY2tlZCk7Cit2b2lkIHRjcF9jb25nX2F2b2lkX2FpKHN0cnVjdCB0Y3Bfc29jayAqdHAsIHUzMiB3LCB1MzIgYWNrZWQpOwogCiB1MzIgdGNwX3Jlbm9fc3N0aHJlc2goc3RydWN0IHNvY2sgKnNrKTsKIHZvaWQgdGNwX3Jlbm9fY29uZ19hdm9pZChzdHJ1Y3Qgc29jayAqc2ssIHUzMiBhY2ssIHUzMiBhY2tlZCk7CmRpZmYgLS1naXQgYS9pbmNsdWRlL3JkbWEvaWJfdmVyYnMuaCBiL2luY2x1ZGUvcmRtYS9pYl92ZXJicy5oCmluZGV4IDBkNzRmMWQuLjY1OTk0YTEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvcmRtYS9pYl92ZXJicy5oCisrKyBiL2luY2x1ZGUvcmRtYS9pYl92ZXJicy5oCkBAIC0xNzA3LDEwICsxNzA3LDcgQEAKIAogc3RhdGljIGlubGluZSBpbnQgaWJfY29weV90b191ZGF0YShzdHJ1Y3QgaWJfdWRhdGEgKnVkYXRhLCB2b2lkICpzcmMsIHNpemVfdCBsZW4pCiB7Ci0Jc2l6ZV90IGNvcHlfc3o7Ci0KLQljb3B5X3N6ID0gbWluX3Qoc2l6ZV90LCBsZW4sIHVkYXRhLT5vdXRsZW4pOwotCXJldHVybiBjb3B5X3RvX3VzZXIodWRhdGEtPm91dGJ1Ziwgc3JjLCBjb3B5X3N6KSA/IC1FRkFVTFQgOiAwOworCXJldHVybiBjb3B5X3RvX3VzZXIodWRhdGEtPm91dGJ1Ziwgc3JjLCBsZW4pID8gLUVGQVVMVCA6IDA7CiB9CiAKIC8qKgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9zb3VuZC9hazQxMTMuaCBiL2luY2x1ZGUvc291bmQvYWs0MTEzLmgKaW5kZXggMjYwOTA0OC4uM2EzNGY2ZSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9zb3VuZC9hazQxMTMuaAorKysgYi9pbmNsdWRlL3NvdW5kL2FrNDExMy5oCkBAIC0yODYsNyArMjg2LDcgQEAKIAlhazQxMTNfd3JpdGVfdCAqd3JpdGU7CiAJYWs0MTEzX3JlYWRfdCAqcmVhZDsKIAl2b2lkICpwcml2YXRlX2RhdGE7Ci0JdW5zaWduZWQgaW50IGluaXQ6MTsKKwlhdG9taWNfdCB3cV9wcm9jZXNzaW5nOwogCXNwaW5sb2NrX3QgbG9jazsKIAl1bnNpZ25lZCBjaGFyIHJlZ21hcFtBSzQxMTNfV1JJVEFCTEVfUkVHU107CiAJc3RydWN0IHNuZF9rY29udHJvbCAqa2N0bHNbQUs0MTEzX0NPTlRST0xTXTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvc291bmQvYWs0MTE0LmggYi9pbmNsdWRlL3NvdW5kL2FrNDExNC5oCmluZGV4IDUyZjAyYTYuLjA2OTI5OWEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvc291bmQvYWs0MTE0LmgKKysrIGIvaW5jbHVkZS9zb3VuZC9hazQxMTQuaApAQCAtMTY4LDcgKzE2OCw3IEBACiAJYWs0MTE0X3dyaXRlX3QgKiB3cml0ZTsKIAlhazQxMTRfcmVhZF90ICogcmVhZDsKIAl2b2lkICogcHJpdmF0ZV9kYXRhOwotCXVuc2lnbmVkIGludCBpbml0OiAxOworCWF0b21pY190IHdxX3Byb2Nlc3Npbmc7CiAJc3BpbmxvY2tfdCBsb2NrOwogCXVuc2lnbmVkIGNoYXIgcmVnbWFwWzZdOwogCXVuc2lnbmVkIGNoYXIgdHhjc2JbNV07CmRpZmYgLS1naXQgYS9pbmNsdWRlL3NvdW5kL3NvYy5oIGIvaW5jbHVkZS9zb3VuZC9zb2MuaAppbmRleCBiNGZjYTlhLi5hYzhiMzMzIDEwMDY0NAotLS0gYS9pbmNsdWRlL3NvdW5kL3NvYy5oCisrKyBiL2luY2x1ZGUvc291bmQvc29jLmgKQEAgLTQ5OCw2ICs0OTgsNyBAQAogCQkJCXVuc2lnbmVkIGludCBtYXNrLCB1bnNpZ25lZCBpbnQgdmFsdWUpOwogCiAjaWZkZWYgQ09ORklHX1NORF9TT0NfQUM5N19CVVMKK3N0cnVjdCBzbmRfYWM5NyAqc25kX3NvY19hbGxvY19hYzk3X2NvZGVjKHN0cnVjdCBzbmRfc29jX2NvZGVjICpjb2RlYyk7CiBzdHJ1Y3Qgc25kX2FjOTcgKnNuZF9zb2NfbmV3X2FjOTdfY29kZWMoc3RydWN0IHNuZF9zb2NfY29kZWMgKmNvZGVjKTsKIHZvaWQgc25kX3NvY19mcmVlX2FjOTdfY29kZWMoc3RydWN0IHNuZF9hYzk3ICphYzk3KTsKIApkaWZmIC0tZ2l0IGEvaW5jbHVkZS90cmFjZS9ldmVudHMva3ZtLmggYi9pbmNsdWRlL3RyYWNlL2V2ZW50cy9rdm0uaAppbmRleCA2ZWRmMWYyLi44NmIzOTljIDEwMDY0NAotLS0gYS9pbmNsdWRlL3RyYWNlL2V2ZW50cy9rdm0uaAorKysgYi9pbmNsdWRlL3RyYWNlL2V2ZW50cy9rdm0uaApAQCAtMTQ2LDYgKzE0NiwxNCBAQAogCiAjaWYgZGVmaW5lZChDT05GSUdfSEFWRV9LVk1fSVJRRkQpCiAKKyNpZmRlZiBrdm1faXJxY2hpcHMKKyNkZWZpbmUga3ZtX2Fja19pcnFfc3RyaW5nICJpcnFjaGlwICVzIHBpbiAldSIKKyNkZWZpbmUga3ZtX2Fja19pcnFfcGFybSAgX19wcmludF9zeW1ib2xpYyhfX2VudHJ5LT5pcnFjaGlwLCBrdm1faXJxY2hpcHMpLCBfX2VudHJ5LT5waW4KKyNlbHNlCisjZGVmaW5lIGt2bV9hY2tfaXJxX3N0cmluZyAiaXJxY2hpcCAlZCBwaW4gJXUiCisjZGVmaW5lIGt2bV9hY2tfaXJxX3Bhcm0gIF9fZW50cnktPmlycWNoaXAsIF9fZW50cnktPnBpbgorI2VuZGlmCisKIFRSQUNFX0VWRU5UKGt2bV9hY2tfaXJxLAogCVRQX1BST1RPKHVuc2lnbmVkIGludCBpcnFjaGlwLCB1bnNpZ25lZCBpbnQgcGluKSwKIAlUUF9BUkdTKGlycWNoaXAsIHBpbiksCkBAIC0xNjAsMTMgKzE2OCw3IEBACiAJCV9fZW50cnktPnBpbgkJPSBwaW47CiAJKSwKIAotI2lmZGVmIGt2bV9pcnFjaGlwcwotCVRQX3ByaW50aygiaXJxY2hpcCAlcyBwaW4gJXUiLAotCQkgIF9fcHJpbnRfc3ltYm9saWMoX19lbnRyeS0+aXJxY2hpcCwga3ZtX2lycWNoaXBzKSwKLQkJIF9fZW50cnktPnBpbikKLSNlbHNlCi0JVFBfcHJpbnRrKCJpcnFjaGlwICVkIHBpbiAldSIsIF9fZW50cnktPmlycWNoaXAsIF9fZW50cnktPnBpbikKLSNlbmRpZgorCVRQX3ByaW50ayhrdm1fYWNrX2lycV9zdHJpbmcsIGt2bV9hY2tfaXJxX3Bhcm0pCiApOwogCiAjZW5kaWYgLyogZGVmaW5lZChDT05GSUdfSEFWRV9LVk1fSVJRRkQpICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL3RyYWNlL2V2ZW50cy90bGIuaCBiL2luY2x1ZGUvdHJhY2UvZXZlbnRzL3RsYi5oCmluZGV4IDEzMzkxZDIuLjBlNzYzNTcgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvdHJhY2UvZXZlbnRzL3RsYi5oCisrKyBiL2luY2x1ZGUvdHJhY2UvZXZlbnRzL3RsYi5oCkBAIC0xMywxMSArMTMsMTMgQEAKIAl7IFRMQl9MT0NBTF9TSE9PVERPV04sCQkibG9jYWwgc2hvb3Rkb3duIiB9LAkJXAogCXsgVExCX0xPQ0FMX01NX1NIT09URE9XTiwJImxvY2FsIG1tIHNob290ZG93biIgfQogCi1UUkFDRV9FVkVOVCh0bGJfZmx1c2gsCitUUkFDRV9FVkVOVF9DT05ESVRJT04odGxiX2ZsdXNoLAogCiAJVFBfUFJPVE8oaW50IHJlYXNvbiwgdW5zaWduZWQgbG9uZyBwYWdlcyksCiAJVFBfQVJHUyhyZWFzb24sIHBhZ2VzKSwKIAorCVRQX0NPTkRJVElPTihjcHVfb25saW5lKHNtcF9wcm9jZXNzb3JfaWQoKSkpLAorCiAJVFBfU1RSVUNUX19lbnRyeSgKIAkJX19maWVsZCgJICBpbnQsIHJlYXNvbikKIAkJX19maWVsZCh1bnNpZ25lZCBsb25nLCAgcGFnZXMpCmRpZmYgLS1naXQgYS9pbmNsdWRlL3VhcGkvbGludXgvY2FuL25ldGxpbmsuaCBiL2luY2x1ZGUvdWFwaS9saW51eC9jYW4vbmV0bGluay5oCmluZGV4IDNlNDMyM2EuLjk0ZmZlMGMgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvdWFwaS9saW51eC9jYW4vbmV0bGluay5oCisrKyBiL2luY2x1ZGUvdWFwaS9saW51eC9jYW4vbmV0bGluay5oCkBAIC05OCw2ICs5OCw3IEBACiAjZGVmaW5lIENBTl9DVFJMTU9ERV9CRVJSX1JFUE9SVElORwkweDEwCS8qIEJ1cy1lcnJvciByZXBvcnRpbmcgKi8KICNkZWZpbmUgQ0FOX0NUUkxNT0RFX0ZECQkJMHgyMAkvKiBDQU4gRkQgbW9kZSAqLwogI2RlZmluZSBDQU5fQ1RSTE1PREVfUFJFU1VNRV9BQ0sJMHg0MAkvKiBJZ25vcmUgbWlzc2luZyBDQU4gQUNLcyAqLworI2RlZmluZSBDQU5fQ1RSTE1PREVfRkRfTk9OX0lTTwkJMHg4MAkvKiBDQU4gRkQgaW4gbm9uLUlTTyBtb2RlICovCiAKIC8qCiAgKiBDQU4gZGV2aWNlIHN0YXRpc3RpY3MKZGlmZiAtLWdpdCBhL2luY2x1ZGUvdWFwaS9saW51eC91aW5wdXQuaCBiL2luY2x1ZGUvdWFwaS9saW51eC91aW5wdXQuaAppbmRleCBiYWVhYjgzLi4wMTNjOWQ4IDEwMDY0NAotLS0gYS9pbmNsdWRlL3VhcGkvbGludXgvdWlucHV0LmgKKysrIGIvaW5jbHVkZS91YXBpL2xpbnV4L3VpbnB1dC5oCkBAIC04Miw3ICs4Miw3IEBACiAgKiBUaGUgY29tcGxldGUgc3lzZnMgcGF0aCBpcyB0aGVuIC9zeXMvZGV2aWNlcy92aXJ0dWFsL2lucHV0Ly0tTkFNRS0tCiAgKiBVc3VhbGx5LCBpdCBpcyBpbiB0aGUgZm9ybSAiaW5wdXROIgogICovCi0jZGVmaW5lIFVJX0dFVF9TWVNOQU1FKGxlbikJX0lPQyhfSU9DX1JFQUQsIFVJTlBVVF9JT0NUTF9CQVNFLCAzMDAsIGxlbikKKyNkZWZpbmUgVUlfR0VUX1NZU05BTUUobGVuKQlfSU9DKF9JT0NfUkVBRCwgVUlOUFVUX0lPQ1RMX0JBU0UsIDQ0LCBsZW4pCiAKIC8qKgogICogVUlfR0VUX1ZFUlNJT04gLSBSZXR1cm4gdmVyc2lvbiBvZiB1aW5wdXQgcHJvdG9jb2wKQEAgLTkxLDcgKzkxLDcgQEAKICAqIHRoZSBpbnRlZ2VyIHBvaW50ZWQgdG8gYnkgdGhlIGlvY3RsIGFyZ3VtZW50LiBUaGUgcHJvdG9jb2wgdmVyc2lvbgogICogaXMgaGFyZC1jb2RlZCBpbiB0aGUga2VybmVsIGFuZCBpcyBpbmRlcGVuZGVudCBvZiB0aGUgdWlucHV0IGRldmljZS4KICAqLwotI2RlZmluZSBVSV9HRVRfVkVSU0lPTgkJX0lPUihVSU5QVVRfSU9DVExfQkFTRSwgMzAxLCB1bnNpZ25lZCBpbnQpCisjZGVmaW5lIFVJX0dFVF9WRVJTSU9OCQlfSU9SKFVJTlBVVF9JT0NUTF9CQVNFLCA0NSwgdW5zaWduZWQgaW50KQogCiAvKgogICogVG8gd3JpdGUgYSBmb3JjZS1mZWVkYmFjay1jYXBhYmxlIGRyaXZlciwgdGhlIHVwbG9hZF9lZmZlY3QKZGlmZiAtLWdpdCBhL2luY2x1ZGUvdWFwaS9yZG1hL2liX3VzZXJfdmVyYnMuaCBiL2luY2x1ZGUvdWFwaS9yZG1hL2liX3VzZXJfdmVyYnMuaAppbmRleCA0Mjc1Yjk2Li44NjdjYzUwIDEwMDY0NAotLS0gYS9pbmNsdWRlL3VhcGkvcmRtYS9pYl91c2VyX3ZlcmJzLmgKKysrIGIvaW5jbHVkZS91YXBpL3JkbWEvaWJfdXNlcl92ZXJicy5oCkBAIC05MCw3ICs5MCw2IEBACiB9OwogCiBlbnVtIHsKLQlJQl9VU0VSX1ZFUkJTX0VYX0NNRF9RVUVSWV9ERVZJQ0UgPSBJQl9VU0VSX1ZFUkJTX0NNRF9RVUVSWV9ERVZJQ0UsCiAJSUJfVVNFUl9WRVJCU19FWF9DTURfQ1JFQVRFX0ZMT1cgPSBJQl9VU0VSX1ZFUkJTX0NNRF9USFJFU0hPTEQsCiAJSUJfVVNFUl9WRVJCU19FWF9DTURfREVTVFJPWV9GTE9XLAogfTsKQEAgLTIwMiwzMiArMjAxLDYgQEAKIAlfX3U4ICByZXNlcnZlZFs0XTsKIH07CiAKLWVudW0gewotCUlCX1VTRVJfVkVSQlNfRVhfUVVFUllfREVWSUNFX09EUCA9CQkxVUxMIDw8IDAsCi19OwotCi1zdHJ1Y3QgaWJfdXZlcmJzX2V4X3F1ZXJ5X2RldmljZSB7Ci0JX191MzIgY29tcF9tYXNrOwotCV9fdTMyIHJlc2VydmVkOwotfTsKLQotc3RydWN0IGliX3V2ZXJic19vZHBfY2FwcyB7Ci0JX191NjQgZ2VuZXJhbF9jYXBzOwotCXN0cnVjdCB7Ci0JCV9fdTMyIHJjX29kcF9jYXBzOwotCQlfX3UzMiB1Y19vZHBfY2FwczsKLQkJX191MzIgdWRfb2RwX2NhcHM7Ci0JfSBwZXJfdHJhbnNwb3J0X2NhcHM7Ci0JX191MzIgcmVzZXJ2ZWQ7Ci19OwotCi1zdHJ1Y3QgaWJfdXZlcmJzX2V4X3F1ZXJ5X2RldmljZV9yZXNwIHsKLQlzdHJ1Y3QgaWJfdXZlcmJzX3F1ZXJ5X2RldmljZV9yZXNwIGJhc2U7Ci0JX191MzIgY29tcF9tYXNrOwotCV9fdTMyIHJlc2VydmVkOwotCXN0cnVjdCBpYl91dmVyYnNfb2RwX2NhcHMgb2RwX2NhcHM7Ci19OwotCiBzdHJ1Y3QgaWJfdXZlcmJzX3F1ZXJ5X3BvcnQgewogCV9fdTY0IHJlc3BvbnNlOwogCV9fdTggIHBvcnRfbnVtOwpkaWZmIC0tZ2l0IGEva2VybmVsL2JwZi9jb3JlLmMgYi9rZXJuZWwvYnBmL2NvcmUuYwppbmRleCBkNjU5NGU0Li5hNjRlN2EyIDEwMDY0NAotLS0gYS9rZXJuZWwvYnBmL2NvcmUuYworKysgYi9rZXJuZWwvYnBmL2NvcmUuYwpAQCAtMTYzLDcgKzE2Myw3IEBACiAKIHZvaWQgYnBmX2ppdF9iaW5hcnlfZnJlZShzdHJ1Y3QgYnBmX2JpbmFyeV9oZWFkZXIgKmhkcikKIHsKLQltb2R1bGVfZnJlZShOVUxMLCBoZHIpOworCW1vZHVsZV9tZW1mcmVlKGhkcik7CiB9CiAjZW5kaWYgLyogQ09ORklHX0JQRl9KSVQgKi8KIApkaWZmIC0tZ2l0IGEva2VybmVsL2JwZi9zeXNjYWxsLmMgYi9rZXJuZWwvYnBmL3N5c2NhbGwuYwppbmRleCAwODhhYzBiLi41MzZlZGMyIDEwMDY0NAotLS0gYS9rZXJuZWwvYnBmL3N5c2NhbGwuYworKysgYi9rZXJuZWwvYnBmL3N5c2NhbGwuYwpAQCAtMTUwLDcgKzE1MCw3IEBACiAJaW50IHVmZCA9IGF0dHItPm1hcF9mZDsKIAlzdHJ1Y3QgZmQgZiA9IGZkZ2V0KHVmZCk7CiAJc3RydWN0IGJwZl9tYXAgKm1hcDsKLQl2b2lkICprZXksICp2YWx1ZTsKKwl2b2lkICprZXksICp2YWx1ZSwgKnB0cjsKIAlpbnQgZXJyOwogCiAJaWYgKENIRUNLX0FUVFIoQlBGX01BUF9MT09LVVBfRUxFTSkpCkBAIC0xNjksMjAgKzE2OSwyOSBAQAogCWlmIChjb3B5X2Zyb21fdXNlcihrZXksIHVrZXksIG1hcC0+a2V5X3NpemUpICE9IDApCiAJCWdvdG8gZnJlZV9rZXk7CiAKLQllcnIgPSAtRU5PRU5UOwotCXJjdV9yZWFkX2xvY2soKTsKLQl2YWx1ZSA9IG1hcC0+b3BzLT5tYXBfbG9va3VwX2VsZW0obWFwLCBrZXkpOworCWVyciA9IC1FTk9NRU07CisJdmFsdWUgPSBrbWFsbG9jKG1hcC0+dmFsdWVfc2l6ZSwgR0ZQX1VTRVIpOwogCWlmICghdmFsdWUpCi0JCWdvdG8gZXJyX3VubG9jazsKKwkJZ290byBmcmVlX2tleTsKKworCXJjdV9yZWFkX2xvY2soKTsKKwlwdHIgPSBtYXAtPm9wcy0+bWFwX2xvb2t1cF9lbGVtKG1hcCwga2V5KTsKKwlpZiAocHRyKQorCQltZW1jcHkodmFsdWUsIHB0ciwgbWFwLT52YWx1ZV9zaXplKTsKKwlyY3VfcmVhZF91bmxvY2soKTsKKworCWVyciA9IC1FTk9FTlQ7CisJaWYgKCFwdHIpCisJCWdvdG8gZnJlZV92YWx1ZTsKIAogCWVyciA9IC1FRkFVTFQ7CiAJaWYgKGNvcHlfdG9fdXNlcih1dmFsdWUsIHZhbHVlLCBtYXAtPnZhbHVlX3NpemUpICE9IDApCi0JCWdvdG8gZXJyX3VubG9jazsKKwkJZ290byBmcmVlX3ZhbHVlOwogCiAJZXJyID0gMDsKIAotZXJyX3VubG9jazoKLQlyY3VfcmVhZF91bmxvY2soKTsKK2ZyZWVfdmFsdWU6CisJa2ZyZWUodmFsdWUpOwogZnJlZV9rZXk6CiAJa2ZyZWUoa2V5KTsKIGVycl9wdXQ6CmRpZmYgLS1naXQgYS9rZXJuZWwvY2dyb3VwLmMgYi9rZXJuZWwvY2dyb3VwLmMKaW5kZXggYmIyNjNkMC4uMDRjZmU4YSAxMDA2NDQKLS0tIGEva2VybmVsL2Nncm91cC5jCisrKyBiL2tlcm5lbC9jZ3JvdXAuYwpAQCAtMTkwOSw3ICsxOTA5LDcgQEAKIAkgKgogCSAqIEFuZCBkb24ndCBraWxsIHRoZSBkZWZhdWx0IHJvb3QuCiAJICovCi0JaWYgKGNzc19oYXNfb25saW5lX2NoaWxkcmVuKCZyb290LT5jZ3JwLnNlbGYpIHx8CisJaWYgKCFsaXN0X2VtcHR5KCZyb290LT5jZ3JwLnNlbGYuY2hpbGRyZW4pIHx8CiAJICAgIHJvb3QgPT0gJmNncnBfZGZsX3Jvb3QpCiAJCWNncm91cF9wdXQoJnJvb3QtPmNncnApOwogCWVsc2UKZGlmZiAtLWdpdCBhL2tlcm5lbC9kZWJ1Zy9rZGIva2RiX21haW4uYyBiL2tlcm5lbC9kZWJ1Zy9rZGIva2RiX21haW4uYwppbmRleCBmMTkxYmRkLi43YjQwYzVmIDEwMDY0NAotLS0gYS9rZXJuZWwvZGVidWcva2RiL2tkYl9tYWluLmMKKysrIGIva2VybmVsL2RlYnVnL2tkYi9rZGJfbWFpbi5jCkBAIC0yMDIzLDcgKzIwMjMsNyBAQAogCQlrZGJfcHJpbnRmKCIlLTIwcyU4dSAgMHglcCAiLCBtb2QtPm5hbWUsCiAJCQkgICBtb2QtPmNvcmVfc2l6ZSwgKHZvaWQgKiltb2QpOwogI2lmZGVmIENPTkZJR19NT0RVTEVfVU5MT0FECi0JCWtkYl9wcmludGYoIiU0bGQgIiwgbW9kdWxlX3JlZmNvdW50KG1vZCkpOworCQlrZGJfcHJpbnRmKCIlNGQgIiwgbW9kdWxlX3JlZmNvdW50KG1vZCkpOwogI2VuZGlmCiAJCWlmIChtb2QtPnN0YXRlID09IE1PRFVMRV9TVEFURV9HT0lORykKIAkJCWtkYl9wcmludGYoIiAoVW5sb2FkaW5nKSIpOwpkaWZmIC0tZ2l0IGEva2VybmVsL2V2ZW50cy9jb3JlLmMgYi9rZXJuZWwvZXZlbnRzL2NvcmUuYwppbmRleCA4ODJmODM1Li4xOWVmY2YxIDEwMDY0NAotLS0gYS9rZXJuZWwvZXZlbnRzL2NvcmUuYworKysgYi9rZXJuZWwvZXZlbnRzL2NvcmUuYwpAQCAtNjc3Niw3ICs2Nzc2LDYgQEAKIAkJX19wZXJmX2V2ZW50X2luaXRfY29udGV4dCgmY3B1Y3R4LT5jdHgpOwogCQlsb2NrZGVwX3NldF9jbGFzcygmY3B1Y3R4LT5jdHgubXV0ZXgsICZjcHVjdHhfbXV0ZXgpOwogCQlsb2NrZGVwX3NldF9jbGFzcygmY3B1Y3R4LT5jdHgubG9jaywgJmNwdWN0eF9sb2NrKTsKLQkJY3B1Y3R4LT5jdHgudHlwZSA9IGNwdV9jb250ZXh0OwogCQljcHVjdHgtPmN0eC5wbXUgPSBwbXU7CiAKIAkJX19wZXJmX2NwdV9ocnRpbWVyX2luaXQoY3B1Y3R4LCBjcHUpOwpAQCAtNzQyMCw3ICs3NDE5LDE5IEBACiAJCSAqIHRhc2sgb3IgQ1BVIGNvbnRleHQ6CiAJCSAqLwogCQlpZiAobW92ZV9ncm91cCkgewotCQkJaWYgKGdyb3VwX2xlYWRlci0+Y3R4LT50eXBlICE9IGN0eC0+dHlwZSkKKwkJCS8qCisJCQkgKiBNYWtlIHN1cmUgd2UncmUgYm90aCBvbiB0aGUgc2FtZSB0YXNrLCBvciBib3RoCisJCQkgKiBwZXItY3B1IGV2ZW50cy4KKwkJCSAqLworCQkJaWYgKGdyb3VwX2xlYWRlci0+Y3R4LT50YXNrICE9IGN0eC0+dGFzaykKKwkJCQlnb3RvIGVycl9jb250ZXh0OworCisJCQkvKgorCQkJICogTWFrZSBzdXJlIHdlJ3JlIGJvdGggZXZlbnRzIGZvciB0aGUgc2FtZSBDUFU7CisJCQkgKiBncm91cGluZyBldmVudHMgZm9yIGRpZmZlcmVudCBDUFVzIGlzIGJyb2tlbjsgc2luY2UKKwkJCSAqIHlvdSBjYW4gbmV2ZXIgY29uY3VycmVudGx5IHNjaGVkdWxlIHRoZW0gYW55aG93LgorCQkJICovCisJCQlpZiAoZ3JvdXBfbGVhZGVyLT5jcHUgIT0gZXZlbnQtPmNwdSkKIAkJCQlnb3RvIGVycl9jb250ZXh0OwogCQl9IGVsc2UgewogCQkJaWYgKGdyb3VwX2xlYWRlci0+Y3R4ICE9IGN0eCkKZGlmZiAtLWdpdCBhL2tlcm5lbC9rcHJvYmVzLmMgYi9rZXJuZWwva3Byb2Jlcy5jCmluZGV4IDA2ZjU4MzAuLmVlNjE5OTIgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9rcHJvYmVzLmMKKysrIGIva2VybmVsL2twcm9iZXMuYwpAQCAtMTI3LDcgKzEyNyw3IEBACiAKIHN0YXRpYyB2b2lkIGZyZWVfaW5zbl9wYWdlKHZvaWQgKnBhZ2UpCiB7Ci0JbW9kdWxlX2ZyZWUoTlVMTCwgcGFnZSk7CisJbW9kdWxlX21lbWZyZWUocGFnZSk7CiB9CiAKIHN0cnVjdCBrcHJvYmVfaW5zbl9jYWNoZSBrcHJvYmVfaW5zbl9zbG90cyA9IHsKZGlmZiAtLWdpdCBhL2tlcm5lbC9tb2R1bGUuYyBiL2tlcm5lbC9tb2R1bGUuYwppbmRleCAzOTY1NTExLi5kODU2ZTk2IDEwMDY0NAotLS0gYS9rZXJuZWwvbW9kdWxlLmMKKysrIGIva2VybmVsL21vZHVsZS5jCkBAIC03NzIsOSArNzcyLDE4IEBACiAJcmV0dXJuIDA7CiB9CiAKLXVuc2lnbmVkIGxvbmcgbW9kdWxlX3JlZmNvdW50KHN0cnVjdCBtb2R1bGUgKm1vZCkKKy8qKgorICogbW9kdWxlX3JlZmNvdW50IC0gcmV0dXJuIHRoZSByZWZjb3VudCBvciAtMSBpZiB1bmxvYWRpbmcKKyAqCisgKiBAbW9kOgl0aGUgbW9kdWxlIHdlJ3JlIGNoZWNraW5nCisgKgorICogUmV0dXJuczoKKyAqCS0xIGlmIHRoZSBtb2R1bGUgaXMgaW4gdGhlIHByb2Nlc3Mgb2YgdW5sb2FkaW5nCisgKglvdGhlcndpc2UgdGhlIG51bWJlciBvZiByZWZlcmVuY2VzIGluIHRoZSBrZXJuZWwgdG8gdGhlIG1vZHVsZQorICovCitpbnQgbW9kdWxlX3JlZmNvdW50KHN0cnVjdCBtb2R1bGUgKm1vZCkKIHsKLQlyZXR1cm4gKHVuc2lnbmVkIGxvbmcpYXRvbWljX3JlYWQoJm1vZC0+cmVmY250KSAtIE1PRFVMRV9SRUZfQkFTRTsKKwlyZXR1cm4gYXRvbWljX3JlYWQoJm1vZC0+cmVmY250KSAtIE1PRFVMRV9SRUZfQkFTRTsKIH0KIEVYUE9SVF9TWU1CT0wobW9kdWxlX3JlZmNvdW50KTsKIApAQCAtODU2LDcgKzg2NSw3IEBACiAJc3RydWN0IG1vZHVsZV91c2UgKnVzZTsKIAlpbnQgcHJpbnRlZF9zb21ldGhpbmcgPSAwOwogCi0Jc2VxX3ByaW50ZihtLCAiICVsdSAiLCBtb2R1bGVfcmVmY291bnQobW9kKSk7CisJc2VxX3ByaW50ZihtLCAiICVpICIsIG1vZHVsZV9yZWZjb3VudChtb2QpKTsKIAogCS8qCiAJICogQWx3YXlzIGluY2x1ZGUgYSB0cmFpbGluZyAsIHNvIHVzZXJzcGFjZSBjYW4gZGlmZmVyZW50aWF0ZQpAQCAtOTA4LDcgKzkxNyw3IEBACiBzdGF0aWMgc3NpemVfdCBzaG93X3JlZmNudChzdHJ1Y3QgbW9kdWxlX2F0dHJpYnV0ZSAqbWF0dHIsCiAJCQkgICBzdHJ1Y3QgbW9kdWxlX2tvYmplY3QgKm1rLCBjaGFyICpidWZmZXIpCiB7Ci0JcmV0dXJuIHNwcmludGYoYnVmZmVyLCAiJWx1XG4iLCBtb2R1bGVfcmVmY291bnQobWstPm1vZCkpOworCXJldHVybiBzcHJpbnRmKGJ1ZmZlciwgIiVpXG4iLCBtb2R1bGVfcmVmY291bnQobWstPm1vZCkpOwogfQogCiBzdGF0aWMgc3RydWN0IG1vZHVsZV9hdHRyaWJ1dGUgbW9kaW5mb19yZWZjbnQgPQpAQCAtMTc5NSw3ICsxODA0LDcgQEAKIHN0YXRpYyB2b2lkIHVuc2V0X21vZHVsZV9pbml0X3JvX254KHN0cnVjdCBtb2R1bGUgKm1vZCkgeyB9CiAjZW5kaWYKIAotdm9pZCBfX3dlYWsgbW9kdWxlX2ZyZWUoc3RydWN0IG1vZHVsZSAqbW9kLCB2b2lkICptb2R1bGVfcmVnaW9uKQordm9pZCBfX3dlYWsgbW9kdWxlX21lbWZyZWUodm9pZCAqbW9kdWxlX3JlZ2lvbikKIHsKIAl2ZnJlZShtb2R1bGVfcmVnaW9uKTsKIH0KQEAgLTE4MDQsNiArMTgxMywxMCBAQAogewogfQogCit2b2lkIF9fd2VhayBtb2R1bGVfYXJjaF9mcmVlaW5nX2luaXQoc3RydWN0IG1vZHVsZSAqbW9kKQoreworfQorCiAvKiBGcmVlIGEgbW9kdWxlLCByZW1vdmUgZnJvbSBsaXN0cywgZXRjLiAqLwogc3RhdGljIHZvaWQgZnJlZV9tb2R1bGUoc3RydWN0IG1vZHVsZSAqbW9kKQogewpAQCAtMTg0MSw3ICsxODU0LDggQEAKIAogCS8qIFRoaXMgbWF5IGJlIE5VTEwsIGJ1dCB0aGF0J3MgT0sgKi8KIAl1bnNldF9tb2R1bGVfaW5pdF9yb19ueChtb2QpOwotCW1vZHVsZV9mcmVlKG1vZCwgbW9kLT5tb2R1bGVfaW5pdCk7CisJbW9kdWxlX2FyY2hfZnJlZWluZ19pbml0KG1vZCk7CisJbW9kdWxlX21lbWZyZWUobW9kLT5tb2R1bGVfaW5pdCk7CiAJa2ZyZWUobW9kLT5hcmdzKTsKIAlwZXJjcHVfbW9kZnJlZShtb2QpOwogCkBAIC0xODUwLDcgKzE4NjQsNyBAQAogCiAJLyogRmluYWxseSwgZnJlZSB0aGUgY29yZSAoY29udGFpbmluZyB0aGUgbW9kdWxlIHN0cnVjdHVyZSkgKi8KIAl1bnNldF9tb2R1bGVfY29yZV9yb19ueChtb2QpOwotCW1vZHVsZV9mcmVlKG1vZCwgbW9kLT5tb2R1bGVfY29yZSk7CisJbW9kdWxlX21lbWZyZWUobW9kLT5tb2R1bGVfY29yZSk7CiAKICNpZmRlZiBDT05GSUdfTVBVCiAJdXBkYXRlX3Byb3RlY3Rpb25zKGN1cnJlbnQtPm1tKTsKQEAgLTI3ODUsNyArMjc5OSw3IEBACiAJCSAqLwogCQlrbWVtbGVha19pZ25vcmUocHRyKTsKIAkJaWYgKCFwdHIpIHsKLQkJCW1vZHVsZV9mcmVlKG1vZCwgbW9kLT5tb2R1bGVfY29yZSk7CisJCQltb2R1bGVfbWVtZnJlZShtb2QtPm1vZHVsZV9jb3JlKTsKIAkJCXJldHVybiAtRU5PTUVNOwogCQl9CiAJCW1lbXNldChwdHIsIDAsIG1vZC0+aW5pdF9zaXplKTsKQEAgLTI5MzAsOCArMjk0NCw5IEBACiBzdGF0aWMgdm9pZCBtb2R1bGVfZGVhbGxvY2F0ZShzdHJ1Y3QgbW9kdWxlICptb2QsIHN0cnVjdCBsb2FkX2luZm8gKmluZm8pCiB7CiAJcGVyY3B1X21vZGZyZWUobW9kKTsKLQltb2R1bGVfZnJlZShtb2QsIG1vZC0+bW9kdWxlX2luaXQpOwotCW1vZHVsZV9mcmVlKG1vZCwgbW9kLT5tb2R1bGVfY29yZSk7CisJbW9kdWxlX2FyY2hfZnJlZWluZ19pbml0KG1vZCk7CisJbW9kdWxlX21lbWZyZWUobW9kLT5tb2R1bGVfaW5pdCk7CisJbW9kdWxlX21lbWZyZWUobW9kLT5tb2R1bGVfY29yZSk7CiB9CiAKIGludCBfX3dlYWsgbW9kdWxlX2ZpbmFsaXplKGNvbnN0IEVsZl9FaGRyICpoZHIsCkBAIC0yOTgzLDEwICsyOTk4LDMxIEBACiAjZW5kaWYKIH0KIAorLyogRm9yIGZyZWVpbmcgbW9kdWxlX2luaXQgb24gc3VjY2VzcywgaW4gY2FzZSBrYWxsc3ltcyB0cmF2ZXJzaW5nICovCitzdHJ1Y3QgbW9kX2luaXRmcmVlIHsKKwlzdHJ1Y3QgcmN1X2hlYWQgcmN1OworCXZvaWQgKm1vZHVsZV9pbml0OworfTsKKworc3RhdGljIHZvaWQgZG9fZnJlZV9pbml0KHN0cnVjdCByY3VfaGVhZCAqaGVhZCkKK3sKKwlzdHJ1Y3QgbW9kX2luaXRmcmVlICptID0gY29udGFpbmVyX29mKGhlYWQsIHN0cnVjdCBtb2RfaW5pdGZyZWUsIHJjdSk7CisJbW9kdWxlX21lbWZyZWUobS0+bW9kdWxlX2luaXQpOworCWtmcmVlKG0pOworfQorCiAvKiBUaGlzIGlzIHdoZXJlIHRoZSByZWFsIHdvcmsgaGFwcGVucyAqLwogc3RhdGljIGludCBkb19pbml0X21vZHVsZShzdHJ1Y3QgbW9kdWxlICptb2QpCiB7CiAJaW50IHJldCA9IDA7CisJc3RydWN0IG1vZF9pbml0ZnJlZSAqZnJlZWluaXQ7CisKKwlmcmVlaW5pdCA9IGttYWxsb2Moc2l6ZW9mKCpmcmVlaW5pdCksIEdGUF9LRVJORUwpOworCWlmICghZnJlZWluaXQpIHsKKwkJcmV0ID0gLUVOT01FTTsKKwkJZ290byBmYWlsOworCX0KKwlmcmVlaW5pdC0+bW9kdWxlX2luaXQgPSBtb2QtPm1vZHVsZV9pbml0OwogCiAJLyoKIAkgKiBXZSB3YW50IHRvIGZpbmQgb3V0IHdoZXRoZXIgQG1vZCB1c2VzIGFzeW5jIGR1cmluZyBpbml0LiAgQ2xlYXIKQEAgLTI5OTksMTggKzMwMzUsNyBAQAogCWlmIChtb2QtPmluaXQgIT0gTlVMTCkKIAkJcmV0ID0gZG9fb25lX2luaXRjYWxsKG1vZC0+aW5pdCk7CiAJaWYgKHJldCA8IDApIHsKLQkJLyoKLQkJICogSW5pdCByb3V0aW5lIGZhaWxlZDogYWJvcnQuICBUcnkgdG8gcHJvdGVjdCB1cyBmcm9tCi0JCSAqIGJ1Z2d5IHJlZmNvdW50ZXJzLgotCQkgKi8KLQkJbW9kLT5zdGF0ZSA9IE1PRFVMRV9TVEFURV9HT0lORzsKLQkJc3luY2hyb25pemVfc2NoZWQoKTsKLQkJbW9kdWxlX3B1dChtb2QpOwotCQlibG9ja2luZ19ub3RpZmllcl9jYWxsX2NoYWluKCZtb2R1bGVfbm90aWZ5X2xpc3QsCi0JCQkJCSAgICAgTU9EVUxFX1NUQVRFX0dPSU5HLCBtb2QpOwotCQlmcmVlX21vZHVsZShtb2QpOwotCQl3YWtlX3VwX2FsbCgmbW9kdWxlX3dxKTsKLQkJcmV0dXJuIHJldDsKKwkJZ290byBmYWlsX2ZyZWVfZnJlZWluaXQ7CiAJfQogCWlmIChyZXQgPiAwKSB7CiAJCXByX3dhcm4oIiVzOiAnJXMnLT5pbml0IHN1c3BpY2lvdXNseSByZXR1cm5lZCAlZCwgaXQgc2hvdWxkICIKQEAgLTMwNTUsMTUgKzMwODAsMzUgQEAKIAltb2QtPnN0cnRhYiA9IG1vZC0+Y29yZV9zdHJ0YWI7CiAjZW5kaWYKIAl1bnNldF9tb2R1bGVfaW5pdF9yb19ueChtb2QpOwotCW1vZHVsZV9mcmVlKG1vZCwgbW9kLT5tb2R1bGVfaW5pdCk7CisJbW9kdWxlX2FyY2hfZnJlZWluZ19pbml0KG1vZCk7CiAJbW9kLT5tb2R1bGVfaW5pdCA9IE5VTEw7CiAJbW9kLT5pbml0X3NpemUgPSAwOwogCW1vZC0+aW5pdF9yb19zaXplID0gMDsKIAltb2QtPmluaXRfdGV4dF9zaXplID0gMDsKKwkvKgorCSAqIFdlIHdhbnQgdG8gZnJlZSBtb2R1bGVfaW5pdCwgYnV0IGJlIGF3YXJlIHRoYXQga2FsbHN5bXMgbWF5IGJlCisJICogd2Fsa2luZyB0aGlzIHdpdGggcHJlZW1wdCBkaXNhYmxlZC4gIEluIGFsbCB0aGUgZmFpbHVyZSBwYXRocywKKwkgKiB3ZSBjYWxsIHN5bmNocm9uaXplX3JjdS9zeW5jaHJvbml6ZV9zY2hlZCwgYnV0IHdlIGRvbid0IHdhbnQKKwkgKiB0byBzbG93IGRvd24gdGhlIHN1Y2Nlc3MgcGF0aCwgc28gdXNlIGFjdHVhbCBSQ1UgaGVyZS4KKwkgKi8KKwljYWxsX3JjdSgmZnJlZWluaXQtPnJjdSwgZG9fZnJlZV9pbml0KTsKIAltdXRleF91bmxvY2soJm1vZHVsZV9tdXRleCk7CiAJd2FrZV91cF9hbGwoJm1vZHVsZV93cSk7CiAKIAlyZXR1cm4gMDsKKworZmFpbF9mcmVlX2ZyZWVpbml0OgorCWtmcmVlKGZyZWVpbml0KTsKK2ZhaWw6CisJLyogVHJ5IHRvIHByb3RlY3QgdXMgZnJvbSBidWdneSByZWZjb3VudGVycy4gKi8KKwltb2QtPnN0YXRlID0gTU9EVUxFX1NUQVRFX0dPSU5HOworCXN5bmNocm9uaXplX3NjaGVkKCk7CisJbW9kdWxlX3B1dChtb2QpOworCWJsb2NraW5nX25vdGlmaWVyX2NhbGxfY2hhaW4oJm1vZHVsZV9ub3RpZnlfbGlzdCwKKwkJCQkgICAgIE1PRFVMRV9TVEFURV9HT0lORywgbW9kKTsKKwlmcmVlX21vZHVsZShtb2QpOworCXdha2VfdXBfYWxsKCZtb2R1bGVfd3EpOworCXJldHVybiByZXQ7CiB9CiAKIHN0YXRpYyBpbnQgbWF5X2luaXRfbW9kdWxlKHZvaWQpCmRpZmYgLS1naXQgYS9rZXJuZWwvcGFyYW1zLmMgYi9rZXJuZWwvcGFyYW1zLmMKaW5kZXggMGFmOWIyYy4uNzI4ZTA1YiAxMDA2NDQKLS0tIGEva2VybmVsL3BhcmFtcy5jCisrKyBiL2tlcm5lbC9wYXJhbXMuYwpAQCAtNjQyLDEyICs2NDIsMTUgQEAKIAltay0+bXAtPmdycC5hdHRycyA9IG5ld19hdHRyczsKIAogCS8qIFRhY2sgbmV3IG9uZSBvbiB0aGUgZW5kLiAqLworCW1lbXNldCgmbWstPm1wLT5hdHRyc1ttay0+bXAtPm51bV0sIDAsIHNpemVvZihtay0+bXAtPmF0dHJzWzBdKSk7CiAJc3lzZnNfYXR0cl9pbml0KCZtay0+bXAtPmF0dHJzW21rLT5tcC0+bnVtXS5tYXR0ci5hdHRyKTsKIAltay0+bXAtPmF0dHJzW21rLT5tcC0+bnVtXS5wYXJhbSA9IGtwOwogCW1rLT5tcC0+YXR0cnNbbWstPm1wLT5udW1dLm1hdHRyLnNob3cgPSBwYXJhbV9hdHRyX3Nob3c7CiAJLyogRG8gbm90IGFsbG93IHJ1bnRpbWUgREFDIGNoYW5nZXMgdG8gbWFrZSBwYXJhbSB3cml0YWJsZS4gKi8KIAlpZiAoKGtwLT5wZXJtICYgKFNfSVdVU1IgfCBTX0lXR1JQIHwgU19JV09USCkpICE9IDApCiAJCW1rLT5tcC0+YXR0cnNbbWstPm1wLT5udW1dLm1hdHRyLnN0b3JlID0gcGFyYW1fYXR0cl9zdG9yZTsKKwllbHNlCisJCW1rLT5tcC0+YXR0cnNbbWstPm1wLT5udW1dLm1hdHRyLnN0b3JlID0gTlVMTDsKIAltay0+bXAtPmF0dHJzW21rLT5tcC0+bnVtXS5tYXR0ci5hdHRyLm5hbWUgPSAoY2hhciAqKW5hbWU7CiAJbWstPm1wLT5hdHRyc1ttay0+bXAtPm51bV0ubWF0dHIuYXR0ci5tb2RlID0ga3AtPnBlcm07CiAJbWstPm1wLT5udW0rKzsKZGlmZiAtLWdpdCBhL2tlcm5lbC9wb3dlci9xb3MuYyBiL2tlcm5lbC9wb3dlci9xb3MuYwppbmRleCA1ZjRjMDA2Li45N2IwZGY3IDEwMDY0NAotLS0gYS9rZXJuZWwvcG93ZXIvcW9zLmMKKysrIGIva2VybmVsL3Bvd2VyL3Fvcy5jCkBAIC00MSw2ICs0MSw4IEBACiAjaW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+CiAjaW5jbHVkZSA8bGludXgvaW5pdC5oPgogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L2RlYnVnZnMuaD4KKyNpbmNsdWRlIDxsaW51eC9zZXFfZmlsZS5oPgogCiAjaW5jbHVkZSA8bGludXgvdWFjY2Vzcy5oPgogI2luY2x1ZGUgPGxpbnV4L2V4cG9ydC5oPgpAQCAtMTgyLDYgKzE4NCw4MSBAQAogCWMtPnRhcmdldF92YWx1ZSA9IHZhbHVlOwogfQogCitzdGF0aWMgaW5saW5lIGludCBwbV9xb3NfZ2V0X3ZhbHVlKHN0cnVjdCBwbV9xb3NfY29uc3RyYWludHMgKmMpOworc3RhdGljIGludCBwbV9xb3NfZGJnX3Nob3dfcmVxdWVzdHMoc3RydWN0IHNlcV9maWxlICpzLCB2b2lkICp1bnVzZWQpCit7CisJc3RydWN0IHBtX3Fvc19vYmplY3QgKnFvcyA9IChzdHJ1Y3QgcG1fcW9zX29iamVjdCAqKXMtPnByaXZhdGU7CisJc3RydWN0IHBtX3Fvc19jb25zdHJhaW50cyAqYzsKKwlzdHJ1Y3QgcG1fcW9zX3JlcXVlc3QgKnJlcTsKKwljaGFyICp0eXBlOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJaW50IHRvdF9yZXFzID0gMDsKKwlpbnQgYWN0aXZlX3JlcXMgPSAwOworCisJaWYgKElTX0VSUl9PUl9OVUxMKHFvcykpIHsKKwkJcHJfZXJyKCIlczogYmFkIHFvcyBwYXJhbSFcbiIsIF9fZnVuY19fKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCWMgPSBxb3MtPmNvbnN0cmFpbnRzOworCWlmIChJU19FUlJfT1JfTlVMTChjKSkgeworCQlwcl9lcnIoIiVzOiBCYWQgY29uc3RyYWludHMgb24gcW9zP1xuIiwgX19mdW5jX18pOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwkvKiBMb2NrIHRvIGVuc3VyZSB3ZSBoYXZlIGEgc25hcHNob3QgKi8KKwlzcGluX2xvY2tfaXJxc2F2ZSgmcG1fcW9zX2xvY2ssIGZsYWdzKTsKKwlpZiAocGxpc3RfaGVhZF9lbXB0eSgmYy0+bGlzdCkpIHsKKwkJc2VxX3B1dHMocywgIkVtcHR5IVxuIik7CisJCWdvdG8gb3V0OworCX0KKworCXN3aXRjaCAoYy0+dHlwZSkgeworCWNhc2UgUE1fUU9TX01JTjoKKwkJdHlwZSA9ICJNaW5pbXVtIjsKKwkJYnJlYWs7CisJY2FzZSBQTV9RT1NfTUFYOgorCQl0eXBlID0gIk1heGltdW0iOworCQlicmVhazsKKwljYXNlIFBNX1FPU19TVU06CisJCXR5cGUgPSAiU3VtIjsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJdHlwZSA9ICJVbmtub3duIjsKKwl9CisKKwlwbGlzdF9mb3JfZWFjaF9lbnRyeShyZXEsICZjLT5saXN0LCBub2RlKSB7CisJCWNoYXIgKnN0YXRlID0gIkRlZmF1bHQiOworCisJCWlmICgocmVxLT5ub2RlKS5wcmlvICE9IGMtPmRlZmF1bHRfdmFsdWUpIHsKKwkJCWFjdGl2ZV9yZXFzKys7CisJCQlzdGF0ZSA9ICJBY3RpdmUiOworCQl9CisJCXRvdF9yZXFzKys7CisJCXNlcV9wcmludGYocywgIiVkOiAlZDogJXNcbiIsIHRvdF9yZXFzLAorCQkJICAgKHJlcS0+bm9kZSkucHJpbywgc3RhdGUpOworCX0KKworCXNlcV9wcmludGYocywgIlR5cGU9JXMsIFZhbHVlPSVkLCBSZXF1ZXN0czogYWN0aXZlPSVkIC8gdG90YWw9JWRcbiIsCisJCSAgIHR5cGUsIHBtX3Fvc19nZXRfdmFsdWUoYyksIGFjdGl2ZV9yZXFzLCB0b3RfcmVxcyk7CisKK291dDoKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwbV9xb3NfbG9jaywgZmxhZ3MpOworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IHBtX3Fvc19kYmdfb3BlbihzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSkKK3sKKwlyZXR1cm4gc2luZ2xlX29wZW4oZmlsZSwgcG1fcW9zX2RiZ19zaG93X3JlcXVlc3RzLAorCQkJICAgaW5vZGUtPmlfcHJpdmF0ZSk7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIHBtX3Fvc19kZWJ1Z19mb3BzID0geworCS5vcGVuICAgICAgICAgICA9IHBtX3Fvc19kYmdfb3BlbiwKKwkucmVhZCAgICAgICAgICAgPSBzZXFfcmVhZCwKKwkubGxzZWVrICAgICAgICAgPSBzZXFfbHNlZWssCisJLnJlbGVhc2UgICAgICAgID0gc2luZ2xlX3JlbGVhc2UsCit9OworCiAvKioKICAqIHBtX3Fvc191cGRhdGVfdGFyZ2V0IC0gbWFuYWdlcyB0aGUgY29uc3RyYWludHMgbGlzdCBhbmQgY2FsbHMgdGhlIG5vdGlmaWVycwogICogIGlmIG5lZWRlZApAQCAtNTA5LDEyICs1ODYsMTcgQEAKIEVYUE9SVF9TWU1CT0xfR1BMKHBtX3Fvc19yZW1vdmVfbm90aWZpZXIpOwogCiAvKiBVc2VyIHNwYWNlIGludGVyZmFjZSB0byBQTSBRb1MgY2xhc3NlcyB2aWEgbWlzYyBkZXZpY2VzICovCi1zdGF0aWMgaW50IHJlZ2lzdGVyX3BtX3Fvc19taXNjKHN0cnVjdCBwbV9xb3Nfb2JqZWN0ICpxb3MpCitzdGF0aWMgaW50IHJlZ2lzdGVyX3BtX3Fvc19taXNjKHN0cnVjdCBwbV9xb3Nfb2JqZWN0ICpxb3MsIHN0cnVjdCBkZW50cnkgKmQpCiB7CiAJcW9zLT5wbV9xb3NfcG93ZXJfbWlzY2Rldi5taW5vciA9IE1JU0NfRFlOQU1JQ19NSU5PUjsKIAlxb3MtPnBtX3Fvc19wb3dlcl9taXNjZGV2Lm5hbWUgPSBxb3MtPm5hbWU7CiAJcW9zLT5wbV9xb3NfcG93ZXJfbWlzY2Rldi5mb3BzID0gJnBtX3Fvc19wb3dlcl9mb3BzOwogCisJaWYgKGQpIHsKKwkJKHZvaWQpZGVidWdmc19jcmVhdGVfZmlsZShxb3MtPm5hbWUsIFNfSVJVR08sIGQsCisJCQkJCSAgKHZvaWQgKilxb3MsICZwbV9xb3NfZGVidWdfZm9wcyk7CisJfQorCiAJcmV0dXJuIG1pc2NfcmVnaXN0ZXIoJnFvcy0+cG1fcW9zX3Bvd2VyX21pc2NkZXYpOwogfQogCkBAIC02MDgsMTEgKzY5MCwxNiBAQAogewogCWludCByZXQgPSAwOwogCWludCBpOworCXN0cnVjdCBkZW50cnkgKmQ7CiAKIAlCVUlMRF9CVUdfT04oQVJSQVlfU0laRShwbV9xb3NfYXJyYXkpICE9IFBNX1FPU19OVU1fQ0xBU1NFUyk7CiAKKwlkID0gZGVidWdmc19jcmVhdGVfZGlyKCJwbV9xb3MiLCBOVUxMKTsKKwlpZiAoSVNfRVJSX09SX05VTEwoZCkpCisJCWQgPSBOVUxMOworCiAJZm9yIChpID0gUE1fUU9TX0NQVV9ETUFfTEFURU5DWTsgaSA8IFBNX1FPU19OVU1fQ0xBU1NFUzsgaSsrKSB7Ci0JCXJldCA9IHJlZ2lzdGVyX3BtX3Fvc19taXNjKHBtX3Fvc19hcnJheVtpXSk7CisJCXJldCA9IHJlZ2lzdGVyX3BtX3Fvc19taXNjKHBtX3Fvc19hcnJheVtpXSwgZCk7CiAJCWlmIChyZXQgPCAwKSB7CiAJCQlwcmludGsoS0VSTl9FUlIgInBtX3Fvc19wYXJhbTogJXMgc2V0dXAgZmFpbGVkXG4iLAogCQkJICAgICAgIHBtX3Fvc19hcnJheVtpXS0+bmFtZSk7CmRpZmYgLS1naXQgYS9rZXJuZWwvcmVzb3VyY2UuYyBiL2tlcm5lbC9yZXNvdXJjZS5jCmluZGV4IDBiY2ViZmYuLjE5ZjIzNTcgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9yZXNvdXJjZS5jCisrKyBiL2tlcm5lbC9yZXNvdXJjZS5jCkBAIC0yMiw2ICsyMiw3IEBACiAjaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+CiAjaW5jbHVkZSA8bGludXgvcGZuLmg+CiAjaW5jbHVkZSA8bGludXgvbW0uaD4KKyNpbmNsdWRlIDxsaW51eC9yZXNvdXJjZV9leHQuaD4KICNpbmNsdWRlIDxhc20vaW8uaD4KIAogCkBAIC0xNTI5LDYgKzE1MzAsMzAgQEAKIAlyZXR1cm4gZXJyOwogfQogCitzdHJ1Y3QgcmVzb3VyY2VfZW50cnkgKnJlc291cmNlX2xpc3RfY3JlYXRlX2VudHJ5KHN0cnVjdCByZXNvdXJjZSAqcmVzLAorCQkJCQkJICBzaXplX3QgZXh0cmFfc2l6ZSkKK3sKKwlzdHJ1Y3QgcmVzb3VyY2VfZW50cnkgKmVudHJ5OworCisJZW50cnkgPSBremFsbG9jKHNpemVvZigqZW50cnkpICsgZXh0cmFfc2l6ZSwgR0ZQX0tFUk5FTCk7CisJaWYgKGVudHJ5KSB7CisJCUlOSVRfTElTVF9IRUFEKCZlbnRyeS0+bm9kZSk7CisJCWVudHJ5LT5yZXMgPSByZXMgPyByZXMgOiAmZW50cnktPl9fcmVzOworCX0KKworCXJldHVybiBlbnRyeTsKK30KK0VYUE9SVF9TWU1CT0wocmVzb3VyY2VfbGlzdF9jcmVhdGVfZW50cnkpOworCit2b2lkIHJlc291cmNlX2xpc3RfZnJlZShzdHJ1Y3QgbGlzdF9oZWFkICpoZWFkKQoreworCXN0cnVjdCByZXNvdXJjZV9lbnRyeSAqZW50cnksICp0bXA7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoZW50cnksIHRtcCwgaGVhZCwgbm9kZSkKKwkJcmVzb3VyY2VfbGlzdF9kZXN0cm95X2VudHJ5KGVudHJ5KTsKK30KK0VYUE9SVF9TWU1CT0wocmVzb3VyY2VfbGlzdF9mcmVlKTsKKwogc3RhdGljIGludCBfX2luaXQgc3RyaWN0X2lvbWVtKGNoYXIgKnN0cikKIHsKIAlpZiAoc3Ryc3RyKHN0ciwgInJlbGF4ZWQiKSkKZGlmZiAtLWdpdCBhL2tlcm5lbC9zY2hlZC9jb3JlLmMgYi9rZXJuZWwvc2NoZWQvY29yZS5jCmluZGV4IGMwYWNjYzAuLjVlYWIxMWQgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9zY2hlZC9jb3JlLmMKKysrIGIva2VybmVsL3NjaGVkL2NvcmUuYwpAQCAtMTgxNCw2ICsxODE0LDEwIEBACiAJZGxfc2UtPmRsX3BlcmlvZCA9IDA7CiAJZGxfc2UtPmZsYWdzID0gMDsKIAlkbF9zZS0+ZGxfYncgPSAwOworCisJZGxfc2UtPmRsX3Rocm90dGxlZCA9IDA7CisJZGxfc2UtPmRsX25ldyA9IDE7CisJZGxfc2UtPmRsX3lpZWxkZWQgPSAwOwogfQogCiAvKgpAQCAtMTgzOSw3ICsxODQzLDcgQEAKICNlbmRpZgogCiAJUkJfQ0xFQVJfTk9ERSgmcC0+ZGwucmJfbm9kZSk7Ci0JaHJ0aW1lcl9pbml0KCZwLT5kbC5kbF90aW1lciwgQ0xPQ0tfTU9OT1RPTklDLCBIUlRJTUVSX01PREVfUkVMKTsKKwlpbml0X2RsX3Rhc2tfdGltZXIoJnAtPmRsKTsKIAlfX2RsX2NsZWFyX3BhcmFtcyhwKTsKIAogCUlOSVRfTElTVF9IRUFEKCZwLT5ydC5ydW5fbGlzdCk7CkBAIC0yMDQ5LDYgKzIwNTMsOSBAQAogICogYWxsb2NhdGVkIGJhbmR3aWR0aCB0byByZWZsZWN0IHRoZSBuZXcgc2l0dWF0aW9uLgogICoKICAqIFRoaXMgZnVuY3Rpb24gaXMgY2FsbGVkIHdoaWxlIGhvbGRpbmcgcCdzIHJxLT5sb2NrLgorICoKKyAqIFhYWCB3ZSBzaG91bGQgZGVsYXkgYncgY2hhbmdlIHVudGlsIHRoZSB0YXNrJ3MgMC1sYWcgcG9pbnQsIHNlZQorICogX19zZXRwYXJhbV9kbCgpLgogICovCiBzdGF0aWMgaW50IGRsX292ZXJmbG93KHN0cnVjdCB0YXNrX3N0cnVjdCAqcCwgaW50IHBvbGljeSwKIAkJICAgICAgIGNvbnN0IHN0cnVjdCBzY2hlZF9hdHRyICphdHRyKQpAQCAtMzI1MSwxNSArMzI1OCwzMSBAQAogewogCXN0cnVjdCBzY2hlZF9kbF9lbnRpdHkgKmRsX3NlID0gJnAtPmRsOwogCi0JaW5pdF9kbF90YXNrX3RpbWVyKGRsX3NlKTsKIAlkbF9zZS0+ZGxfcnVudGltZSA9IGF0dHItPnNjaGVkX3J1bnRpbWU7CiAJZGxfc2UtPmRsX2RlYWRsaW5lID0gYXR0ci0+c2NoZWRfZGVhZGxpbmU7CiAJZGxfc2UtPmRsX3BlcmlvZCA9IGF0dHItPnNjaGVkX3BlcmlvZCA/OiBkbF9zZS0+ZGxfZGVhZGxpbmU7CiAJZGxfc2UtPmZsYWdzID0gYXR0ci0+c2NoZWRfZmxhZ3M7CiAJZGxfc2UtPmRsX2J3ID0gdG9fcmF0aW8oZGxfc2UtPmRsX3BlcmlvZCwgZGxfc2UtPmRsX3J1bnRpbWUpOwotCWRsX3NlLT5kbF90aHJvdHRsZWQgPSAwOwotCWRsX3NlLT5kbF9uZXcgPSAxOwotCWRsX3NlLT5kbF95aWVsZGVkID0gMDsKKworCS8qCisJICogQ2hhbmdpbmcgdGhlIHBhcmFtZXRlcnMgb2YgYSB0YXNrIGlzICd0cmlja3knIGFuZCB3ZSdyZSBub3QgZG9pbmcKKwkgKiB0aGUgY29ycmVjdCB0aGluZyAtLSBhbHNvIHNlZSB0YXNrX2RlYWRfZGwoKSBhbmQgc3dpdGNoZWRfZnJvbV9kbCgpLgorCSAqCisJICogV2hhdCB3ZSBTSE9VTEQgZG8gaXMgZGVsYXkgdGhlIGJhbmR3aWR0aCByZWxlYXNlIHVudGlsIHRoZSAwLWxhZworCSAqIHBvaW50LiBUaGlzIHdvdWxkIGluY2x1ZGUgcmV0YWluaW5nIHRoZSB0YXNrX3N0cnVjdCB1bnRpbCB0aGF0IHRpbWUKKwkgKiBhbmQgY2hhbmdlIGRsX292ZXJmbG93KCkgdG8gbm90IGltbWVkaWF0ZWx5IGRlY3JlbWVudCB0aGUgY3VycmVudAorCSAqIGFtb3VudC4KKwkgKgorCSAqIEluc3RlYWQgd2UgcmV0YWluIHRoZSBjdXJyZW50IHJ1bnRpbWUvZGVhZGxpbmUgYW5kIGxldCB0aGUgbmV3CisJICogcGFyYW1ldGVycyB0YWtlIGVmZmVjdCBhZnRlciB0aGUgY3VycmVudCByZXNlcnZhdGlvbiBwZXJpb2QgbGFwc2VzLgorCSAqIFRoaXMgaXMgc2FmZSAoYWxiZWl0IHBlc3NpbWlzdGljKSBiZWNhdXNlIHRoZSAwLWxhZyBwb2ludCBpcyBhbHdheXMKKwkgKiBiZWZvcmUgdGhlIGN1cnJlbnQgc2NoZWR1bGluZyBkZWFkbGluZS4KKwkgKgorCSAqIFdlIGNhbiBzdGlsbCBoYXZlIHRlbXBvcmFyeSBvdmVybG9hZHMgYmVjYXVzZSB3ZSBkbyBub3QgZGVsYXkgdGhlCisJICogY2hhbmdlIGluIGJhbmR3aWR0aCB1bnRpbCB0aGF0IHRpbWU7IHNvIGFkbWlzc2lvbiBjb250cm9sIGlzCisJICogbm90IG9uIHRoZSBzYWZlIHNpZGUuIEl0IGRvZXMgaG93ZXZlciBndWFyYW50ZWUgdGFza3Mgd2lsbCBuZXZlcgorCSAqIGNvbnN1bWUgbW9yZSB0aGFuIHByb21pc2VkLgorCSAqLwogfQogCiAvKgpAQCAtNDY0Miw2ICs0NjY1LDkgQEAKIAlzdHJ1Y3QgZGxfYncgKmN1cl9kbF9iOwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKKwlpZiAoIWNwdW1hc2tfd2VpZ2h0KGN1cikpCisJCXJldHVybiByZXQ7CisKIAlyY3VfcmVhZF9sb2NrX3NjaGVkKCk7CiAJY3VyX2RsX2IgPSBkbF9id19vZihjcHVtYXNrX2FueShjdXIpKTsKIAl0cmlhbF9jcHVzID0gY3B1bWFza193ZWlnaHQodHJpYWwpOwpAQCAtNzI5MiwxMyArNzMxOCwxMiBAQAogCSAqIHNpbmNlIHdlIHdpbGwgZXhpdCB3aXRoIFRBU0tfUlVOTklORyBtYWtlIHN1cmUgd2UgZW50ZXIgd2l0aCBpdCwKIAkgKiBvdGhlcndpc2Ugd2Ugd2lsbCBkZXN0cm95IHN0YXRlLgogCSAqLwotCWlmIChXQVJOX09OQ0UoY3VycmVudC0+c3RhdGUgIT0gVEFTS19SVU5OSU5HLAorCVdBUk5fT05DRShjdXJyZW50LT5zdGF0ZSAhPSBUQVNLX1JVTk5JTkcgJiYgY3VycmVudC0+dGFza19zdGF0ZV9jaGFuZ2UsCiAJCQkiZG8gbm90IGNhbGwgYmxvY2tpbmcgb3BzIHdoZW4gIVRBU0tfUlVOTklORzsgIgogCQkJInN0YXRlPSVseCBzZXQgYXQgWzwlcD5dICVwU1xuIiwKIAkJCWN1cnJlbnQtPnN0YXRlLAogCQkJKHZvaWQgKiljdXJyZW50LT50YXNrX3N0YXRlX2NoYW5nZSwKLQkJCSh2b2lkICopY3VycmVudC0+dGFza19zdGF0ZV9jaGFuZ2UpKQotCQlfX3NldF9jdXJyZW50X3N0YXRlKFRBU0tfUlVOTklORyk7CisJCQkodm9pZCAqKWN1cnJlbnQtPnRhc2tfc3RhdGVfY2hhbmdlKTsKIAogCV9fX21pZ2h0X3NsZWVwKGZpbGUsIGxpbmUsIHByZWVtcHRfb2Zmc2V0KTsKIH0KZGlmZiAtLWdpdCBhL2tlcm5lbC9zY2hlZC9kZWFkbGluZS5jIGIva2VybmVsL3NjaGVkL2RlYWRsaW5lLmMKaW5kZXggYjUyMDkyZi4uNzI2NDcwZCAxMDA2NDQKLS0tIGEva2VybmVsL3NjaGVkL2RlYWRsaW5lLmMKKysrIGIva2VybmVsL3NjaGVkL2RlYWRsaW5lLmMKQEAgLTEwOTQsNiArMTA5NCw3IEBACiAJICogU2luY2Ugd2UgYXJlIFRBU0tfREVBRCB3ZSB3b24ndCBzbGlwIG91dCBvZiB0aGUgZG9tYWluIQogCSAqLwogCXJhd19zcGluX2xvY2tfaXJxKCZkbF9iLT5sb2NrKTsKKwkvKiBYWFggd2Ugc2hvdWxkIHJldGFpbiB0aGUgYncgdW50aWwgMC1sYWcgKi8KIAlkbF9iLT50b3RhbF9idyAtPSBwLT5kbC5kbF9idzsKIAlyYXdfc3Bpbl91bmxvY2tfaXJxKCZkbF9iLT5sb2NrKTsKIApAQCAtMTYxNCw4ICsxNjE1LDggQEAKIAogc3RhdGljIHZvaWQgc3dpdGNoZWRfZnJvbV9kbChzdHJ1Y3QgcnEgKnJxLCBzdHJ1Y3QgdGFza19zdHJ1Y3QgKnApCiB7CisJLyogWFhYIHdlIHNob3VsZCByZXRhaW4gdGhlIGJ3IHVudGlsIDAtbGFnICovCiAJY2FuY2VsX2RsX3RpbWVyKHJxLCBwKTsKLQogCV9fZGxfY2xlYXJfcGFyYW1zKHApOwogCiAJLyoKZGlmZiAtLWdpdCBhL2tlcm5lbC9zY2hlZC9mYWlyLmMgYi9rZXJuZWwvc2NoZWQvZmFpci5jCmluZGV4IDQwNjY3Y2IuLmZlMzMxZmMgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9zY2hlZC9mYWlyLmMKKysrIGIva2VybmVsL3NjaGVkL2ZhaXIuYwpAQCAtMTczMCw3ICsxNzMwLDcgQEAKIAlub2RlcyA9IG5vZGVfb25saW5lX21hcDsKIAlmb3IgKGRpc3QgPSBzY2hlZF9tYXhfbnVtYV9kaXN0YW5jZTsgZGlzdCA+IExPQ0FMX0RJU1RBTkNFOyBkaXN0LS0pIHsKIAkJdW5zaWduZWQgbG9uZyBtYXhfZmF1bHRzID0gMDsKLQkJbm9kZW1hc2tfdCBtYXhfZ3JvdXA7CisJCW5vZGVtYXNrX3QgbWF4X2dyb3VwID0gTk9ERV9NQVNLX05PTkU7CiAJCWludCBhLCBiOwogCiAJCS8qIEFyZSB0aGVyZSBub2RlcyBhdCB0aGlzIGRpc3RhbmNlIGZyb20gZWFjaCBvdGhlcj8gKi8KZGlmZiAtLWdpdCBhL2tlcm5lbC9zbXBib290LmMgYi9rZXJuZWwvc21wYm9vdC5jCmluZGV4IGYwMzJmYjUuLjQwMTkwZjIgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9zbXBib290LmMKKysrIGIva2VybmVsL3NtcGJvb3QuYwpAQCAtMjgwLDYgKzI4MCw3IEBACiAJdW5zaWduZWQgaW50IGNwdTsKIAlpbnQgcmV0ID0gMDsKIAorCWdldF9vbmxpbmVfY3B1cygpOwogCW11dGV4X2xvY2soJnNtcGJvb3RfdGhyZWFkc19sb2NrKTsKIAlmb3JfZWFjaF9vbmxpbmVfY3B1KGNwdSkgewogCQlyZXQgPSBfX3NtcGJvb3RfY3JlYXRlX3RocmVhZChwbHVnX3RocmVhZCwgY3B1KTsKQEAgLTI5Miw2ICsyOTMsNyBAQAogCWxpc3RfYWRkKCZwbHVnX3RocmVhZC0+bGlzdCwgJmhvdHBsdWdfdGhyZWFkcyk7CiBvdXQ6CiAJbXV0ZXhfdW5sb2NrKCZzbXBib290X3RocmVhZHNfbG9jayk7CisJcHV0X29ubGluZV9jcHVzKCk7CiAJcmV0dXJuIHJldDsKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKHNtcGJvb3RfcmVnaXN0ZXJfcGVyY3B1X3RocmVhZCk7CmRpZmYgLS1naXQgYS9rZXJuZWwvc3lzLmMgYi9rZXJuZWwvc3lzLmMKaW5kZXggYThjOWY1YS4uZWE5Yzg4MSAxMDA2NDQKLS0tIGEva2VybmVsL3N5cy5jCisrKyBiL2tlcm5lbC9zeXMuYwpAQCAtMjIxMCw5ICsyMjEwLDEzIEBACiAJCXVwX3dyaXRlKCZtZS0+bW0tPm1tYXBfc2VtKTsKIAkJYnJlYWs7CiAJY2FzZSBQUl9NUFhfRU5BQkxFX01BTkFHRU1FTlQ6CisJCWlmIChhcmcyIHx8IGFyZzMgfHwgYXJnNCB8fCBhcmc1KQorCQkJcmV0dXJuIC1FSU5WQUw7CiAJCWVycm9yID0gTVBYX0VOQUJMRV9NQU5BR0VNRU5UKG1lKTsKIAkJYnJlYWs7CiAJY2FzZSBQUl9NUFhfRElTQUJMRV9NQU5BR0VNRU5UOgorCQlpZiAoYXJnMiB8fCBhcmczIHx8IGFyZzQgfHwgYXJnNSkKKwkJCXJldHVybiAtRUlOVkFMOwogCQllcnJvciA9IE1QWF9ESVNBQkxFX01BTkFHRU1FTlQobWUpOwogCQlicmVhazsKIAlkZWZhdWx0OgpkaWZmIC0tZ2l0IGEva2VybmVsL3RpbWUvaHJ0aW1lci5jIGIva2VybmVsL3RpbWUvaHJ0aW1lci5jCmluZGV4IDM3ZTUwYWEuLmQ4YzcyNGMgMTAwNjQ0Ci0tLSBhL2tlcm5lbC90aW1lL2hydGltZXIuYworKysgYi9rZXJuZWwvdGltZS9ocnRpbWVyLmMKQEAgLTEyMiw3ICsxMjIsNyBAQAogCW1vbm8gPSBrdGltZV9nZXRfdXBkYXRlX29mZnNldHNfdGljaygmb2ZmX3JlYWwsICZvZmZfYm9vdCwgJm9mZl90YWkpOwogCWJvb3QgPSBrdGltZV9hZGQobW9ubywgb2ZmX2Jvb3QpOwogCXh0aW0gPSBrdGltZV9hZGQobW9ubywgb2ZmX3JlYWwpOwotCXRhaSA9IGt0aW1lX2FkZCh4dGltLCBvZmZfdGFpKTsKKwl0YWkgPSBrdGltZV9hZGQobW9ubywgb2ZmX3RhaSk7CiAKIAliYXNlLT5jbG9ja19iYXNlW0hSVElNRVJfQkFTRV9SRUFMVElNRV0uc29mdGlycV90aW1lID0geHRpbTsKIAliYXNlLT5jbG9ja19iYXNlW0hSVElNRVJfQkFTRV9NT05PVE9OSUNdLnNvZnRpcnFfdGltZSA9IG1vbm87CmRpZmYgLS1naXQgYS9rZXJuZWwvdGltZS9udHAuYyBiL2tlcm5lbC90aW1lL250cC5jCmluZGV4IDg3YTM0NmYuLjI4YmY5MWMgMTAwNjQ0Ci0tLSBhL2tlcm5lbC90aW1lL250cC5jCisrKyBiL2tlcm5lbC90aW1lL250cC5jCkBAIC02MzMsNiArNjMzLDEzIEBACiAJaWYgKCh0eGMtPm1vZGVzICYgQURKX1NFVE9GRlNFVCkgJiYgKCFjYXBhYmxlKENBUF9TWVNfVElNRSkpKQogCQlyZXR1cm4gLUVQRVJNOwogCisJaWYgKHR4Yy0+bW9kZXMgJiBBREpfRlJFUVVFTkNZKSB7CisJCWlmIChMT05HX01JTiAvIFBQTV9TQ0FMRSA+IHR4Yy0+ZnJlcSkKKwkJCXJldHVybiAtRUlOVkFMOworCQlpZiAoTE9OR19NQVggLyBQUE1fU0NBTEUgPCB0eGMtPmZyZXEpCisJCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKIAlyZXR1cm4gMDsKIH0KIApkaWZmIC0tZ2l0IGEva2VybmVsL3RpbWUvdGltZS5jIGIva2VybmVsL3RpbWUvdGltZS5jCmluZGV4IDYzOTA1MTcuLjJjODViNzcgMTAwNjQ0Ci0tLSBhL2tlcm5lbC90aW1lL3RpbWUuYworKysgYi9rZXJuZWwvdGltZS90aW1lLmMKQEAgLTE5Niw2ICsxOTYsMTAgQEAKIAlpZiAodHYpIHsKIAkJaWYgKGNvcHlfZnJvbV91c2VyKCZ1c2VyX3R2LCB0diwgc2l6ZW9mKCp0dikpKQogCQkJcmV0dXJuIC1FRkFVTFQ7CisKKwkJaWYgKCF0aW1ldmFsX3ZhbGlkKCZ1c2VyX3R2KSkKKwkJCXJldHVybiAtRUlOVkFMOworCiAJCW5ld190cy50dl9zZWMgPSB1c2VyX3R2LnR2X3NlYzsKIAkJbmV3X3RzLnR2X25zZWMgPSB1c2VyX3R2LnR2X3VzZWMgKiBOU0VDX1BFUl9VU0VDOwogCX0KZGlmZiAtLWdpdCBhL2tlcm5lbC93b3JrcXVldWUuYyBiL2tlcm5lbC93b3JrcXVldWUuYwppbmRleCA2MjAyYjA4Li5iZWVlYWM5IDEwMDY0NAotLS0gYS9rZXJuZWwvd29ya3F1ZXVlLmMKKysrIGIva2VybmVsL3dvcmtxdWV1ZS5jCkBAIC0xODQxLDE3ICsxODQxLDExIEBACiAgKiBzcGluX2xvY2tfaXJxKHBvb2wtPmxvY2spIHdoaWNoIG1heSBiZSByZWxlYXNlZCBhbmQgcmVncmFiYmVkCiAgKiBtdWx0aXBsZSB0aW1lcy4gIERvZXMgR0ZQX0tFUk5FTCBhbGxvY2F0aW9ucy4gIENhbGxlZCBvbmx5IGZyb20KICAqIG1hbmFnZXIuCi0gKgotICogUmV0dXJuOgotICogJWZhbHNlIGlmIG5vIGFjdGlvbiB3YXMgdGFrZW4gYW5kIHBvb2wtPmxvY2sgc3RheWVkIGxvY2tlZCwgJXRydWUKLSAqIG90aGVyd2lzZS4KICAqLwotc3RhdGljIGJvb2wgbWF5YmVfY3JlYXRlX3dvcmtlcihzdHJ1Y3Qgd29ya2VyX3Bvb2wgKnBvb2wpCitzdGF0aWMgdm9pZCBtYXliZV9jcmVhdGVfd29ya2VyKHN0cnVjdCB3b3JrZXJfcG9vbCAqcG9vbCkKIF9fcmVsZWFzZXMoJnBvb2wtPmxvY2spCiBfX2FjcXVpcmVzKCZwb29sLT5sb2NrKQogewotCWlmICghbmVlZF90b19jcmVhdGVfd29ya2VyKHBvb2wpKQotCQlyZXR1cm4gZmFsc2U7CiByZXN0YXJ0OgogCXNwaW5fdW5sb2NrX2lycSgmcG9vbC0+bG9jayk7CiAKQEAgLTE4NzcsNyArMTg3MSw2IEBACiAJICovCiAJaWYgKG5lZWRfdG9fY3JlYXRlX3dvcmtlcihwb29sKSkKIAkJZ290byByZXN0YXJ0OwotCXJldHVybiB0cnVlOwogfQogCiAvKioKQEAgLTE4OTcsMTYgKzE4OTAsMTQgQEAKICAqIG11bHRpcGxlIHRpbWVzLiAgRG9lcyBHRlBfS0VSTkVMIGFsbG9jYXRpb25zLgogICoKICAqIFJldHVybjoKLSAqICVmYWxzZSBpZiB0aGUgcG9vbCBkb24ndCBuZWVkIG1hbmFnZW1lbnQgYW5kIHRoZSBjYWxsZXIgY2FuIHNhZmVseSBzdGFydAotICogcHJvY2Vzc2luZyB3b3JrcywgJXRydWUgaW5kaWNhdGVzIHRoYXQgdGhlIGZ1bmN0aW9uIHJlbGVhc2VkIHBvb2wtPmxvY2sKLSAqIGFuZCByZWFjcXVpcmVkIGl0IHRvIHBlcmZvcm0gc29tZSBtYW5hZ2VtZW50IGZ1bmN0aW9uIGFuZCB0aGF0IHRoZQotICogY29uZGl0aW9ucyB0aGF0IHRoZSBjYWxsZXIgdmVyaWZpZWQgd2hpbGUgaG9sZGluZyB0aGUgbG9jayBiZWZvcmUKLSAqIGNhbGxpbmcgdGhlIGZ1bmN0aW9uIG1pZ2h0IG5vIGxvbmdlciBiZSB0cnVlLgorICogJWZhbHNlIGlmIHRoZSBwb29sIGRvZXNuJ3QgbmVlZCBtYW5hZ2VtZW50IGFuZCB0aGUgY2FsbGVyIGNhbiBzYWZlbHkKKyAqIHN0YXJ0IHByb2Nlc3Npbmcgd29ya3MsICV0cnVlIGlmIG1hbmFnZW1lbnQgZnVuY3Rpb24gd2FzIHBlcmZvcm1lZCBhbmQKKyAqIHRoZSBjb25kaXRpb25zIHRoYXQgdGhlIGNhbGxlciB2ZXJpZmllZCBiZWZvcmUgY2FsbGluZyB0aGUgZnVuY3Rpb24gbWF5CisgKiBubyBsb25nZXIgYmUgdHJ1ZS4KICAqLwogc3RhdGljIGJvb2wgbWFuYWdlX3dvcmtlcnMoc3RydWN0IHdvcmtlciAqd29ya2VyKQogewogCXN0cnVjdCB3b3JrZXJfcG9vbCAqcG9vbCA9IHdvcmtlci0+cG9vbDsKLQlib29sIHJldCA9IGZhbHNlOwogCiAJLyoKIAkgKiBBbnlvbmUgd2hvIHN1Y2Nlc3NmdWxseSBncmFicyBtYW5hZ2VyX2FyYiB3aW5zIHRoZSBhcmJpdHJhdGlvbgpAQCAtMTkxOSwxMiArMTkxMCwxMiBAQAogCSAqIGFjdHVhbCBtYW5hZ2VtZW50LCB0aGUgcG9vbCBtYXkgc3RhbGwgaW5kZWZpbml0ZWx5LgogCSAqLwogCWlmICghbXV0ZXhfdHJ5bG9jaygmcG9vbC0+bWFuYWdlcl9hcmIpKQotCQlyZXR1cm4gcmV0OworCQlyZXR1cm4gZmFsc2U7CiAKLQlyZXQgfD0gbWF5YmVfY3JlYXRlX3dvcmtlcihwb29sKTsKKwltYXliZV9jcmVhdGVfd29ya2VyKHBvb2wpOwogCiAJbXV0ZXhfdW5sb2NrKCZwb29sLT5tYW5hZ2VyX2FyYik7Ci0JcmV0dXJuIHJldDsKKwlyZXR1cm4gdHJ1ZTsKIH0KIAogLyoqCmRpZmYgLS1naXQgYS9saWIvY2hlY2tzdW0uYyBiL2xpYi9jaGVja3N1bS5jCmluZGV4IDEyOTc3NWUuLjhiMzllODYgMTAwNjQ0Ci0tLSBhL2xpYi9jaGVja3N1bS5jCisrKyBiL2xpYi9jaGVja3N1bS5jCkBAIC0xODEsNiArMTgxLDE1IEBACiBFWFBPUlRfU1lNQk9MKGNzdW1fcGFydGlhbF9jb3B5KTsKIAogI2lmbmRlZiBjc3VtX3RjcHVkcF9ub2ZvbGQKK3N0YXRpYyBpbmxpbmUgdTMyIGZyb202NHRvMzIodTY0IHgpCit7CisJLyogYWRkIHVwIDMyLWJpdCBhbmQgMzItYml0IGZvciAzMitjIGJpdCAqLworCXggPSAoeCAmIDB4ZmZmZmZmZmYpICsgKHggPj4gMzIpOworCS8qIGFkZCB1cCBjYXJyeS4uICovCisJeCA9ICh4ICYgMHhmZmZmZmZmZikgKyAoeCA+PiAzMik7CisJcmV0dXJuICh1MzIpeDsKK30KKwogX193c3VtIGNzdW1fdGNwdWRwX25vZm9sZChfX2JlMzIgc2FkZHIsIF9fYmUzMiBkYWRkciwKIAkJCXVuc2lnbmVkIHNob3J0IGxlbiwKIAkJCXVuc2lnbmVkIHNob3J0IHByb3RvLApAQCAtMTk1LDggKzIwNCw3IEBACiAjZWxzZQogCXMgKz0gKHByb3RvICsgbGVuKSA8PCA4OwogI2VuZGlmCi0JcyArPSAocyA+PiAzMik7Ci0JcmV0dXJuIChfX2ZvcmNlIF9fd3N1bSlzOworCXJldHVybiAoX19mb3JjZSBfX3dzdW0pZnJvbTY0dG8zMihzKTsKIH0KIEVYUE9SVF9TWU1CT0woY3N1bV90Y3B1ZHBfbm9mb2xkKTsKICNlbmRpZgpkaWZmIC0tZ2l0IGEvbW0vZ3VwLmMgYi9tbS9ndXAuYwppbmRleCBhOTAwNzU5Li44ZGQ1MGNlIDEwMDY0NAotLS0gYS9tbS9ndXAuYworKysgYi9tbS9ndXAuYwpAQCAtMjk2LDcgKzI5Niw3IEBACiAJCQlyZXR1cm4gLUVOT01FTTsKIAkJaWYgKHJldCAmIChWTV9GQVVMVF9IV1BPSVNPTiB8IFZNX0ZBVUxUX0hXUE9JU09OX0xBUkdFKSkKIAkJCXJldHVybiAqZmxhZ3MgJiBGT0xMX0hXUE9JU09OID8gLUVIV1BPSVNPTiA6IC1FRkFVTFQ7Ci0JCWlmIChyZXQgJiBWTV9GQVVMVF9TSUdCVVMpCisJCWlmIChyZXQgJiAoVk1fRkFVTFRfU0lHQlVTIHwgVk1fRkFVTFRfU0lHU0VHVikpCiAJCQlyZXR1cm4gLUVGQVVMVDsKIAkJQlVHKCk7CiAJfQpAQCAtNTcxLDcgKzU3MSw3IEBACiAJCQlyZXR1cm4gLUVOT01FTTsKIAkJaWYgKHJldCAmIChWTV9GQVVMVF9IV1BPSVNPTiB8IFZNX0ZBVUxUX0hXUE9JU09OX0xBUkdFKSkKIAkJCXJldHVybiAtRUhXUE9JU09OOwotCQlpZiAocmV0ICYgVk1fRkFVTFRfU0lHQlVTKQorCQlpZiAocmV0ICYgKFZNX0ZBVUxUX1NJR0JVUyB8IFZNX0ZBVUxUX1NJR1NFR1YpKQogCQkJcmV0dXJuIC1FRkFVTFQ7CiAJCUJVRygpOwogCX0KZGlmZiAtLWdpdCBhL21tL2tzbS5jIGIvbW0va3NtLmMKaW5kZXggZDI0N2VmYS4uMTU2NDdmYiAxMDA2NDQKLS0tIGEvbW0va3NtLmMKKysrIGIvbW0va3NtLmMKQEAgLTM3Niw3ICszNzYsNyBAQAogCQllbHNlCiAJCQlyZXQgPSBWTV9GQVVMVF9XUklURTsKIAkJcHV0X3BhZ2UocGFnZSk7Ci0JfSB3aGlsZSAoIShyZXQgJiAoVk1fRkFVTFRfV1JJVEUgfCBWTV9GQVVMVF9TSUdCVVMgfCBWTV9GQVVMVF9PT00pKSk7CisJfSB3aGlsZSAoIShyZXQgJiAoVk1fRkFVTFRfV1JJVEUgfCBWTV9GQVVMVF9TSUdCVVMgfCBWTV9GQVVMVF9TSUdTRUdWIHwgVk1fRkFVTFRfT09NKSkpOwogCS8qCiAJICogV2UgbXVzdCBsb29wIGJlY2F1c2UgaGFuZGxlX21tX2ZhdWx0KCkgbWF5IGJhY2sgb3V0IGlmIHRoZXJlJ3MKIAkgKiBhbnkgZGlmZmljdWx0eSBlLmcuIGlmIHB0ZSBhY2Nlc3NlZCBiaXQgZ2V0cyB1cGRhdGVkIGNvbmN1cnJlbnRseS4KZGlmZiAtLWdpdCBhL21tL21lbWNvbnRyb2wuYyBiL21tL21lbWNvbnRyb2wuYwppbmRleCA4NTE5MjRmLi4yZjY4OTNjIDEwMDY0NAotLS0gYS9tbS9tZW1jb250cm9sLmMKKysrIGIvbW0vbWVtY29udHJvbC5jCkBAIC0xNDc3LDkgKzE0NzcsOSBAQAogCiAJcHJfaW5mbygiVGFzayBpbiAiKTsKIAlwcl9jb250X2Nncm91cF9wYXRoKHRhc2tfY2dyb3VwKHAsIG1lbW9yeV9jZ3JwX2lkKSk7Ci0JcHJfaW5mbygiIGtpbGxlZCBhcyBhIHJlc3VsdCBvZiBsaW1pdCBvZiAiKTsKKwlwcl9jb250KCIga2lsbGVkIGFzIGEgcmVzdWx0IG9mIGxpbWl0IG9mICIpOwogCXByX2NvbnRfY2dyb3VwX3BhdGgobWVtY2ctPmNzcy5jZ3JvdXApOwotCXByX2luZm8oIlxuIik7CisJcHJfY29udCgiXG4iKTsKIAogCXJjdV9yZWFkX3VubG9jaygpOwogCkBAIC01NzczLDcgKzU3NzMsNyBAQAogICogbWVtX2Nncm91cF9taWdyYXRlIC0gbWlncmF0ZSBhIGNoYXJnZSB0byBhbm90aGVyIHBhZ2UKICAqIEBvbGRwYWdlOiBjdXJyZW50bHkgY2hhcmdlZCBwYWdlCiAgKiBAbmV3cGFnZTogcGFnZSB0byB0cmFuc2ZlciB0aGUgY2hhcmdlIHRvCi0gKiBAbHJ1Y2FyZTogYm90aCBwYWdlcyBtaWdodCBiZSBvbiB0aGUgTFJVIGFscmVhZHkKKyAqIEBscnVjYXJlOiBlaXRoZXIgb3IgYm90aCBwYWdlcyBtaWdodCBiZSBvbiB0aGUgTFJVIGFscmVhZHkKICAqCiAgKiBNaWdyYXRlIHRoZSBjaGFyZ2UgZnJvbSBAb2xkcGFnZSB0byBAbmV3cGFnZS4KICAqCmRpZmYgLS1naXQgYS9tbS9tZW1vcnkuYyBiL21tL21lbW9yeS5jCmluZGV4IDU0ZjNhOWIuLjJjMzUzNmMgMTAwNjQ0Ci0tLSBhL21tL21lbW9yeS5jCisrKyBiL21tL21lbW9yeS5jCkBAIC0yNjMyLDcgKzI2MzIsNyBAQAogCiAJLyogQ2hlY2sgaWYgd2UgbmVlZCB0byBhZGQgYSBndWFyZCBwYWdlIHRvIHRoZSBzdGFjayAqLwogCWlmIChjaGVja19zdGFja19ndWFyZF9wYWdlKHZtYSwgYWRkcmVzcykgPCAwKQotCQlyZXR1cm4gVk1fRkFVTFRfU0lHQlVTOworCQlyZXR1cm4gVk1fRkFVTFRfU0lHU0VHVjsKIAogCS8qIFVzZSB0aGUgemVyby1wYWdlIGZvciByZWFkcyAqLwogCWlmICghKGZsYWdzICYgRkFVTFRfRkxBR19XUklURSkgJiYgIW1tX2ZvcmJpZHNfemVyb3BhZ2UobW0pKSB7CmRpZmYgLS1naXQgYS9tbS9ub21tdS5jIGIvbW0vbm9tbXUuYwppbmRleCBiNTFlYWRmLi4yOGJkOGM0IDEwMDY0NAotLS0gYS9tbS9ub21tdS5jCisrKyBiL21tL25vbW11LmMKQEAgLTU5LDYgKzU5LDcgQEAKICNlbmRpZgogCiB2b2lkICpoaWdoX21lbW9yeTsKK0VYUE9SVF9TWU1CT0woaGlnaF9tZW1vcnkpOwogc3RydWN0IHBhZ2UgKm1lbV9tYXA7CiB1bnNpZ25lZCBsb25nIG1heF9tYXBucjsKIHVuc2lnbmVkIGxvbmcgaGlnaGVzdF9tZW1tYXBfcGZuOwpkaWZmIC0tZ2l0IGEvbW0vcGFnZV9hbGxvYy5jIGIvbW0vcGFnZV9hbGxvYy5jCmluZGV4IDc2MzNjNTAuLjhlMjBmOWMgMTAwNjQ0Ci0tLSBhL21tL3BhZ2VfYWxsb2MuYworKysgYi9tbS9wYWdlX2FsbG9jLmMKQEAgLTIzMzIsMTIgKzIzMzIsMjEgQEAKIF9fYWxsb2NfcGFnZXNfbWF5X29vbShnZnBfdCBnZnBfbWFzaywgdW5zaWduZWQgaW50IG9yZGVyLAogCXN0cnVjdCB6b25lbGlzdCAqem9uZWxpc3QsIGVudW0gem9uZV90eXBlIGhpZ2hfem9uZWlkeCwKIAlub2RlbWFza190ICpub2RlbWFzaywgc3RydWN0IHpvbmUgKnByZWZlcnJlZF96b25lLAotCWludCBjbGFzc3pvbmVfaWR4LCBpbnQgbWlncmF0ZXR5cGUpCisJaW50IGNsYXNzem9uZV9pZHgsIGludCBtaWdyYXRldHlwZSwgdW5zaWduZWQgbG9uZyAqZGlkX3NvbWVfcHJvZ3Jlc3MpCiB7CiAJc3RydWN0IHBhZ2UgKnBhZ2U7CiAKLQkvKiBBY3F1aXJlIHRoZSBwZXItem9uZSBvb20gbG9jayBmb3IgZWFjaCB6b25lICovCisJKmRpZF9zb21lX3Byb2dyZXNzID0gMDsKKworCWlmIChvb21fa2lsbGVyX2Rpc2FibGVkKQorCQlyZXR1cm4gTlVMTDsKKworCS8qCisJICogQWNxdWlyZSB0aGUgcGVyLXpvbmUgb29tIGxvY2sgZm9yIGVhY2ggem9uZS4gIElmIHRoYXQKKwkgKiBmYWlscywgc29tZWJvZHkgZWxzZSBpcyBtYWtpbmcgcHJvZ3Jlc3MgZm9yIHVzLgorCSAqLwogCWlmICghb29tX3pvbmVsaXN0X3RyeWxvY2soem9uZWxpc3QsIGdmcF9tYXNrKSkgeworCQkqZGlkX3NvbWVfcHJvZ3Jlc3MgPSAxOwogCQlzY2hlZHVsZV90aW1lb3V0X3VuaW50ZXJydXB0aWJsZSgxKTsKIAkJcmV0dXJuIE5VTEw7CiAJfQpAQCAtMjM2MywxMiArMjM3MiwxOCBAQAogCQlnb3RvIG91dDsKIAogCWlmICghKGdmcF9tYXNrICYgX19HRlBfTk9GQUlMKSkgeworCQkvKiBDb3JlZHVtcHMgY2FuIHF1aWNrbHkgZGVwbGV0ZSBhbGwgbWVtb3J5IHJlc2VydmVzICovCisJCWlmIChjdXJyZW50LT5mbGFncyAmIFBGX0RVTVBDT1JFKQorCQkJZ290byBvdXQ7CiAJCS8qIFRoZSBPT00ga2lsbGVyIHdpbGwgbm90IGhlbHAgaGlnaGVyIG9yZGVyIGFsbG9jcyAqLwogCQlpZiAob3JkZXIgPiBQQUdFX0FMTE9DX0NPU1RMWV9PUkRFUikKIAkJCWdvdG8gb3V0OwogCQkvKiBUaGUgT09NIGtpbGxlciBkb2VzIG5vdCBuZWVkbGVzc2x5IGtpbGwgdGFza3MgZm9yIGxvd21lbSAqLwogCQlpZiAoaGlnaF96b25laWR4IDwgWk9ORV9OT1JNQUwpCiAJCQlnb3RvIG91dDsKKwkJLyogVGhlIE9PTSBraWxsZXIgZG9lcyBub3QgY29tcGVuc2F0ZSBmb3IgbGlnaHQgcmVjbGFpbSAqLworCQlpZiAoIShnZnBfbWFzayAmIF9fR0ZQX0ZTKSkKKwkJCWdvdG8gb3V0OwogCQkvKgogCQkgKiBHRlBfVEhJU05PREUgY29udGFpbnMgX19HRlBfTk9SRVRSWSBhbmQgd2UgbmV2ZXIgaGl0IHRoaXMuCiAJCSAqIFNhbml0eSBjaGVjayBmb3IgYmFyZSBjYWxscyBvZiBfX0dGUF9USElTTk9ERSwgbm90IHJlYWwgT09NLgpAQCAtMjM4MSw3ICsyMzk2LDcgQEAKIAl9CiAJLyogRXhoYXVzdGVkIHdoYXQgY2FuIGJlIGRvbmUgc28gaXQncyBibGFtbyB0aW1lICovCiAJb3V0X29mX21lbW9yeSh6b25lbGlzdCwgZ2ZwX21hc2ssIG9yZGVyLCBub2RlbWFzaywgZmFsc2UpOwotCisJKmRpZF9zb21lX3Byb2dyZXNzID0gMTsKIG91dDoKIAlvb21fem9uZWxpc3RfdW5sb2NrKHpvbmVsaXN0LCBnZnBfbWFzayk7CiAJcmV0dXJuIHBhZ2U7CkBAIC0yNjU4LDcgKzI2NzMsNyBAQAogCSAgICAoZ2ZwX21hc2sgJiBHRlBfVEhJU05PREUpID09IEdGUF9USElTTk9ERSkKIAkJZ290byBub3BhZ2U7CiAKLXJlc3RhcnQ6CityZXRyeToKIAlpZiAoIShnZnBfbWFzayAmIF9fR0ZQX05PX0tTV0FQRCkpCiAJCXdha2VfYWxsX2tzd2FwZHMob3JkZXIsIHpvbmVsaXN0LCBoaWdoX3pvbmVpZHgsCiAJCQkJcHJlZmVycmVkX3pvbmUsIG5vZGVtYXNrKTsKQEAgLTI2ODEsNyArMjY5Niw2IEBACiAJCWNsYXNzem9uZV9pZHggPSB6b25lbGlzdF96b25lX2lkeChwcmVmZXJyZWRfem9uZXJlZik7CiAJfQogCi1yZWJhbGFuY2U6CiAJLyogVGhpcyBpcyB0aGUgbGFzdCBjaGFuY2UsIGluIGdlbmVyYWwsIGJlZm9yZSB0aGUgZ290byBub3BhZ2UuICovCiAJcGFnZSA9IGdldF9wYWdlX2Zyb21fZnJlZWxpc3QoZ2ZwX21hc2ssIG5vZGVtYXNrLCBvcmRlciwgem9uZWxpc3QsCiAJCQloaWdoX3pvbmVpZHgsIGFsbG9jX2ZsYWdzICYgfkFMTE9DX05PX1dBVEVSTUFSS1MsCkBAIC0yNzg4LDU0ICsyODAyLDI4IEBACiAJaWYgKHBhZ2UpCiAJCWdvdG8gZ290X3BnOwogCi0JLyoKLQkgKiBJZiB3ZSBmYWlsZWQgdG8gbWFrZSBhbnkgcHJvZ3Jlc3MgcmVjbGFpbWluZywgdGhlbiB3ZSBhcmUKLQkgKiBydW5uaW5nIG91dCBvZiBvcHRpb25zIGFuZCBoYXZlIHRvIGNvbnNpZGVyIGdvaW5nIE9PTQotCSAqLwotCWlmICghZGlkX3NvbWVfcHJvZ3Jlc3MpIHsKLQkJaWYgKG9vbV9nZnBfYWxsb3dlZChnZnBfbWFzaykpIHsKLQkJCWlmIChvb21fa2lsbGVyX2Rpc2FibGVkKQotCQkJCWdvdG8gbm9wYWdlOwotCQkJLyogQ29yZWR1bXBzIGNhbiBxdWlja2x5IGRlcGxldGUgYWxsIG1lbW9yeSByZXNlcnZlcyAqLwotCQkJaWYgKChjdXJyZW50LT5mbGFncyAmIFBGX0RVTVBDT1JFKSAmJgotCQkJICAgICEoZ2ZwX21hc2sgJiBfX0dGUF9OT0ZBSUwpKQotCQkJCWdvdG8gbm9wYWdlOwotCQkJcGFnZSA9IF9fYWxsb2NfcGFnZXNfbWF5X29vbShnZnBfbWFzaywgb3JkZXIsCi0JCQkJCXpvbmVsaXN0LCBoaWdoX3pvbmVpZHgsCi0JCQkJCW5vZGVtYXNrLCBwcmVmZXJyZWRfem9uZSwKLQkJCQkJY2xhc3N6b25lX2lkeCwgbWlncmF0ZXR5cGUpOwotCQkJaWYgKHBhZ2UpCi0JCQkJZ290byBnb3RfcGc7Ci0KLQkJCWlmICghKGdmcF9tYXNrICYgX19HRlBfTk9GQUlMKSkgewotCQkJCS8qCi0JCQkJICogVGhlIG9vbSBraWxsZXIgaXMgbm90IGNhbGxlZCBmb3IgaGlnaC1vcmRlcgotCQkJCSAqIGFsbG9jYXRpb25zIHRoYXQgbWF5IGZhaWwsIHNvIGlmIG5vIHByb2dyZXNzCi0JCQkJICogaXMgYmVpbmcgbWFkZSwgdGhlcmUgYXJlIG5vIG90aGVyIG9wdGlvbnMgYW5kCi0JCQkJICogcmV0cnlpbmcgaXMgdW5saWtlbHkgdG8gaGVscC4KLQkJCQkgKi8KLQkJCQlpZiAob3JkZXIgPiBQQUdFX0FMTE9DX0NPU1RMWV9PUkRFUikKLQkJCQkJZ290byBub3BhZ2U7Ci0JCQkJLyoKLQkJCQkgKiBUaGUgb29tIGtpbGxlciBpcyBub3QgY2FsbGVkIGZvciBsb3dtZW0KLQkJCQkgKiBhbGxvY2F0aW9ucyB0byBwcmV2ZW50IG5lZWRsZXNzbHkga2lsbGluZwotCQkJCSAqIGlubm9jZW50IHRhc2tzLgotCQkJCSAqLwotCQkJCWlmIChoaWdoX3pvbmVpZHggPCBaT05FX05PUk1BTCkKLQkJCQkJZ290byBub3BhZ2U7Ci0JCQl9Ci0KLQkJCWdvdG8gcmVzdGFydDsKLQkJfQotCX0KLQogCS8qIENoZWNrIGlmIHdlIHNob3VsZCByZXRyeSB0aGUgYWxsb2NhdGlvbiAqLwogCXBhZ2VzX3JlY2xhaW1lZCArPSBkaWRfc29tZV9wcm9ncmVzczsKIAlpZiAoc2hvdWxkX2FsbG9jX3JldHJ5KGdmcF9tYXNrLCBvcmRlciwgZGlkX3NvbWVfcHJvZ3Jlc3MsCiAJCQkJCQlwYWdlc19yZWNsYWltZWQpKSB7CisJCS8qCisJCSAqIElmIHdlIGZhaWwgdG8gbWFrZSBwcm9ncmVzcyBieSBmcmVlaW5nIGluZGl2aWR1YWwKKwkJICogcGFnZXMsIGJ1dCB0aGUgYWxsb2NhdGlvbiB3YW50cyB1cyB0byBrZWVwIGdvaW5nLAorCQkgKiBzdGFydCBPT00ga2lsbGluZyB0YXNrcy4KKwkJICovCisJCWlmICghZGlkX3NvbWVfcHJvZ3Jlc3MpIHsKKwkJCXBhZ2UgPSBfX2FsbG9jX3BhZ2VzX21heV9vb20oZ2ZwX21hc2ssIG9yZGVyLCB6b25lbGlzdCwKKwkJCQkJCWhpZ2hfem9uZWlkeCwgbm9kZW1hc2ssCisJCQkJCQlwcmVmZXJyZWRfem9uZSwgY2xhc3N6b25lX2lkeCwKKwkJCQkJCW1pZ3JhdGV0eXBlLCZkaWRfc29tZV9wcm9ncmVzcyk7CisJCQlpZiAocGFnZSkKKwkJCQlnb3RvIGdvdF9wZzsKKwkJCWlmICghZGlkX3NvbWVfcHJvZ3Jlc3MpCisJCQkJZ290byBub3BhZ2U7CisJCX0KIAkJLyogV2FpdCBmb3Igc29tZSB3cml0ZSByZXF1ZXN0cyB0byBjb21wbGV0ZSB0aGVuIHJldHJ5ICovCiAJCXdhaXRfaWZmX2Nvbmdlc3RlZChwcmVmZXJyZWRfem9uZSwgQkxLX1JXX0FTWU5DLCBIWi81MCk7Ci0JCWdvdG8gcmViYWxhbmNlOworCQlnb3RvIHJldHJ5OwogCX0gZWxzZSB7CiAJCS8qCiAJCSAqIEhpZ2gtb3JkZXIgYWxsb2NhdGlvbnMgZG8gbm90IG5lY2Vzc2FyaWx5IGxvb3AgYWZ0ZXIKZGlmZiAtLWdpdCBhL21tL3BhZ2V3YWxrLmMgYi9tbS9wYWdld2Fsay5jCmluZGV4IGFkODMxOTUuLmIyNjRiZGEgMTAwNjQ0Ci0tLSBhL21tL3BhZ2V3YWxrLmMKKysrIGIvbW0vcGFnZXdhbGsuYwpAQCAtMTk5LDcgKzE5OSwxMCBAQAogCQkJICovCiAJCQlpZiAoKHZtYS0+dm1fc3RhcnQgPD0gYWRkcikgJiYKIAkJCSAgICAodm1hLT52bV9mbGFncyAmIFZNX1BGTk1BUCkpIHsKLQkJCQluZXh0ID0gdm1hLT52bV9lbmQ7CisJCQkJaWYgKHdhbGstPnB0ZV9ob2xlKQorCQkJCQllcnIgPSB3YWxrLT5wdGVfaG9sZShhZGRyLCBuZXh0LCB3YWxrKTsKKwkJCQlpZiAoZXJyKQorCQkJCQlicmVhazsKIAkJCQlwZ2QgPSBwZ2Rfb2Zmc2V0KHdhbGstPm1tLCBuZXh0KTsKIAkJCQljb250aW51ZTsKIAkJCX0KZGlmZiAtLWdpdCBhL21tL3NobWVtLmMgYi9tbS9zaG1lbS5jCmluZGV4IDczYmExZGYuLjk5M2U2YmEgMTAwNjQ0Ci0tLSBhL21tL3NobWVtLmMKKysrIGIvbW0vc2htZW0uYwpAQCAtMTAxMyw3ICsxMDEzLDcgQEAKIAkJICovCiAJCW9sZHBhZ2UgPSBuZXdwYWdlOwogCX0gZWxzZSB7Ci0JCW1lbV9jZ3JvdXBfbWlncmF0ZShvbGRwYWdlLCBuZXdwYWdlLCBmYWxzZSk7CisJCW1lbV9jZ3JvdXBfbWlncmF0ZShvbGRwYWdlLCBuZXdwYWdlLCB0cnVlKTsKIAkJbHJ1X2NhY2hlX2FkZF9hbm9uKG5ld3BhZ2UpOwogCQkqcGFnZXAgPSBuZXdwYWdlOwogCX0KZGlmZiAtLWdpdCBhL21tL3Ztc2Nhbi5jIGIvbW0vdm1zY2FuLmMKaW5kZXggYWIyNTA1Yy4uZGNkOTBjOCAxMDA2NDQKLS0tIGEvbW0vdm1zY2FuLmMKKysrIGIvbW0vdm1zY2FuLmMKQEAgLTI2NTYsNyArMjY1Niw3IEBACiAJICogc2hvdWxkIG1ha2UgcmVhc29uYWJsZSBwcm9ncmVzcy4KIAkgKi8KIAlmb3JfZWFjaF96b25lX3pvbmVsaXN0X25vZGVtYXNrKHpvbmUsIHosIHpvbmVsaXN0LAotCQkJCQlnZnBfbWFzaywgbm9kZW1hc2spIHsKKwkJCQkJZ2ZwX3pvbmUoZ2ZwX21hc2spLCBub2RlbWFzaykgewogCQlpZiAoem9uZV9pZHgoem9uZSkgPiBaT05FX05PUk1BTCkKIAkJCWNvbnRpbnVlOwogCmRpZmYgLS1naXQgYS9uZXQvYnJpZGdlL25ldGZpbHRlci9uZnRfcmVqZWN0X2JyaWRnZS5jIGIvbmV0L2JyaWRnZS9uZXRmaWx0ZXIvbmZ0X3JlamVjdF9icmlkZ2UuYwppbmRleCBiMDMzMGFlLi4zMjQ0YWVhIDEwMDY0NAotLS0gYS9uZXQvYnJpZGdlL25ldGZpbHRlci9uZnRfcmVqZWN0X2JyaWRnZS5jCisrKyBiL25ldC9icmlkZ2UvbmV0ZmlsdGVyL25mdF9yZWplY3RfYnJpZGdlLmMKQEAgLTI2NSwyMiArMjY1LDEyIEBACiAJZGF0YVtORlRfUkVHX1ZFUkRJQ1RdLnZlcmRpY3QgPSBORl9EUk9QOwogfQogCi1zdGF0aWMgaW50IG5mdF9yZWplY3RfYnJpZGdlX3ZhbGlkYXRlX2hvb2tzKGNvbnN0IHN0cnVjdCBuZnRfY2hhaW4gKmNoYWluKQorc3RhdGljIGludCBuZnRfcmVqZWN0X2JyaWRnZV92YWxpZGF0ZShjb25zdCBzdHJ1Y3QgbmZ0X2N0eCAqY3R4LAorCQkJCSAgICAgIGNvbnN0IHN0cnVjdCBuZnRfZXhwciAqZXhwciwKKwkJCQkgICAgICBjb25zdCBzdHJ1Y3QgbmZ0X2RhdGEgKipkYXRhKQogewotCXN0cnVjdCBuZnRfYmFzZV9jaGFpbiAqYmFzZWNoYWluOwotCi0JaWYgKGNoYWluLT5mbGFncyAmIE5GVF9CQVNFX0NIQUlOKSB7Ci0JCWJhc2VjaGFpbiA9IG5mdF9iYXNlX2NoYWluKGNoYWluKTsKLQotCQlzd2l0Y2ggKGJhc2VjaGFpbi0+b3BzWzBdLmhvb2tudW0pIHsKLQkJY2FzZSBORl9CUl9QUkVfUk9VVElORzoKLQkJY2FzZSBORl9CUl9MT0NBTF9JTjoKLQkJCWJyZWFrOwotCQlkZWZhdWx0OgotCQkJcmV0dXJuIC1FT1BOT1RTVVBQOwotCQl9Ci0JfQotCXJldHVybiAwOworCXJldHVybiBuZnRfY2hhaW5fdmFsaWRhdGVfaG9va3MoY3R4LT5jaGFpbiwgKDEgPDwgTkZfQlJfUFJFX1JPVVRJTkcpIHwKKwkJCQkJCSAgICAoMSA8PCBORl9CUl9MT0NBTF9JTikpOwogfQogCiBzdGF0aWMgaW50IG5mdF9yZWplY3RfYnJpZGdlX2luaXQoY29uc3Qgc3RydWN0IG5mdF9jdHggKmN0eCwKQEAgLTI5MCw3ICsyODAsNyBAQAogCXN0cnVjdCBuZnRfcmVqZWN0ICpwcml2ID0gbmZ0X2V4cHJfcHJpdihleHByKTsKIAlpbnQgaWNtcF9jb2RlLCBlcnI7CiAKLQllcnIgPSBuZnRfcmVqZWN0X2JyaWRnZV92YWxpZGF0ZV9ob29rcyhjdHgtPmNoYWluKTsKKwllcnIgPSBuZnRfcmVqZWN0X2JyaWRnZV92YWxpZGF0ZShjdHgsIGV4cHIsIE5VTEwpOwogCWlmIChlcnIgPCAwKQogCQlyZXR1cm4gZXJyOwogCkBAIC0zNDEsMTMgKzMzMSw2IEBACiAJcmV0dXJuIC0xOwogfQogCi1zdGF0aWMgaW50IG5mdF9yZWplY3RfYnJpZGdlX3ZhbGlkYXRlKGNvbnN0IHN0cnVjdCBuZnRfY3R4ICpjdHgsCi0JCQkJICAgICAgY29uc3Qgc3RydWN0IG5mdF9leHByICpleHByLAotCQkJCSAgICAgIGNvbnN0IHN0cnVjdCBuZnRfZGF0YSAqKmRhdGEpCi17Ci0JcmV0dXJuIG5mdF9yZWplY3RfYnJpZGdlX3ZhbGlkYXRlX2hvb2tzKGN0eC0+Y2hhaW4pOwotfQotCiBzdGF0aWMgc3RydWN0IG5mdF9leHByX3R5cGUgbmZ0X3JlamVjdF9icmlkZ2VfdHlwZTsKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgbmZ0X2V4cHJfb3BzIG5mdF9yZWplY3RfYnJpZGdlX29wcyA9IHsKIAkudHlwZQkJPSAmbmZ0X3JlamVjdF9icmlkZ2VfdHlwZSwKZGlmZiAtLWdpdCBhL25ldC9jYWlmL2NobmxfbmV0LmMgYi9uZXQvY2FpZi9jaG5sX25ldC5jCmluZGV4IDQ1ODlmZjY3Li42N2E0YTM2IDEwMDY0NAotLS0gYS9uZXQvY2FpZi9jaG5sX25ldC5jCisrKyBiL25ldC9jYWlmL2NobmxfbmV0LmMKQEAgLTQ3MCw3ICs0NzAsNiBAQAogCUFTU0VSVF9SVE5MKCk7CiAJY2FpZmRldiA9IG5ldGRldl9wcml2KGRldik7CiAJY2FpZl9uZXRsaW5rX3Bhcm1zKGRhdGEsICZjYWlmZGV2LT5jb25uX3JlcSk7Ci0JZGV2X25ldF9zZXQoY2FpZmRldi0+bmV0ZGV2LCBzcmNfbmV0KTsKIAogCXJldCA9IHJlZ2lzdGVyX25ldGRldmljZShkZXYpOwogCWlmIChyZXQpCmRpZmYgLS1naXQgYS9uZXQvY29yZS9kZXYuYyBiL25ldC9jb3JlL2Rldi5jCmluZGV4IDY4M2Q0OTMuLjdmZTgyOTIgMTAwNjQ0Ci0tLSBhL25ldC9jb3JlL2Rldi5jCisrKyBiL25ldC9jb3JlL2Rldi5jCkBAIC0yMzUyLDcgKzIzNTIsNiBAQAogCiBfX2JlMTYgc2tiX25ldHdvcmtfcHJvdG9jb2woc3RydWN0IHNrX2J1ZmYgKnNrYiwgaW50ICpkZXB0aCkKIHsKLQl1bnNpZ25lZCBpbnQgdmxhbl9kZXB0aCA9IHNrYi0+bWFjX2xlbjsKIAlfX2JlMTYgdHlwZSA9IHNrYi0+cHJvdG9jb2w7CiAKIAkvKiBUdW5uZWwgZ3NvIGhhbmRsZXJzIGNhbiBzZXQgcHJvdG9jb2wgdG8gZXRoZXJuZXQuICovCkBAIC0yMzY2LDM1ICsyMzY1LDcgQEAKIAkJdHlwZSA9IGV0aC0+aF9wcm90bzsKIAl9CiAKLQkvKiBpZiBza2ItPnByb3RvY29sIGlzIDgwMi4xUS9BRCB0aGVuIHRoZSBoZWFkZXIgc2hvdWxkIGFscmVhZHkgYmUKLQkgKiBwcmVzZW50IGF0IG1hY19sZW4gLSBWTEFOX0hMRU4gKGlmIG1hY19sZW4gPiAwKSwgb3IgYXQKLQkgKiBFVEhfSExFTiBvdGhlcndpc2UKLQkgKi8KLQlpZiAodHlwZSA9PSBodG9ucyhFVEhfUF84MDIxUSkgfHwgdHlwZSA9PSBodG9ucyhFVEhfUF84MDIxQUQpKSB7Ci0JCWlmICh2bGFuX2RlcHRoKSB7Ci0JCQlpZiAoV0FSTl9PTih2bGFuX2RlcHRoIDwgVkxBTl9ITEVOKSkKLQkJCQlyZXR1cm4gMDsKLQkJCXZsYW5fZGVwdGggLT0gVkxBTl9ITEVOOwotCQl9IGVsc2UgewotCQkJdmxhbl9kZXB0aCA9IEVUSF9ITEVOOwotCQl9Ci0JCWRvIHsKLQkJCXN0cnVjdCB2bGFuX2hkciAqdmg7Ci0KLQkJCWlmICh1bmxpa2VseSghcHNrYl9tYXlfcHVsbChza2IsCi0JCQkJCQkgICAgdmxhbl9kZXB0aCArIFZMQU5fSExFTikpKQotCQkJCXJldHVybiAwOwotCi0JCQl2aCA9IChzdHJ1Y3Qgdmxhbl9oZHIgKikoc2tiLT5kYXRhICsgdmxhbl9kZXB0aCk7Ci0JCQl0eXBlID0gdmgtPmhfdmxhbl9lbmNhcHN1bGF0ZWRfcHJvdG87Ci0JCQl2bGFuX2RlcHRoICs9IFZMQU5fSExFTjsKLQkJfSB3aGlsZSAodHlwZSA9PSBodG9ucyhFVEhfUF84MDIxUSkgfHwKLQkJCSB0eXBlID09IGh0b25zKEVUSF9QXzgwMjFBRCkpOwotCX0KLQotCSpkZXB0aCA9IHZsYW5fZGVwdGg7Ci0KLQlyZXR1cm4gdHlwZTsKKwlyZXR1cm4gX192bGFuX2dldF9wcm90b2NvbChza2IsIHR5cGUsIGRlcHRoKTsKIH0KIAogLyoqCkBAIC01MzIzLDcgKzUyOTQsNyBAQAogfQogRVhQT1JUX1NZTUJPTChuZXRkZXZfdXBwZXJfZGV2X3VubGluayk7CiAKLXZvaWQgbmV0ZGV2X2FkamFjZW50X2FkZF9saW5rcyhzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQorc3RhdGljIHZvaWQgbmV0ZGV2X2FkamFjZW50X2FkZF9saW5rcyhzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQogewogCXN0cnVjdCBuZXRkZXZfYWRqYWNlbnQgKml0ZXI7CiAKQEAgLTUzNDgsNyArNTMxOSw3IEBACiAJfQogfQogCi12b2lkIG5ldGRldl9hZGphY2VudF9kZWxfbGlua3Moc3RydWN0IG5ldF9kZXZpY2UgKmRldikKK3N0YXRpYyB2b2lkIG5ldGRldl9hZGphY2VudF9kZWxfbGlua3Moc3RydWN0IG5ldF9kZXZpY2UgKmRldikKIHsKIAlzdHJ1Y3QgbmV0ZGV2X2FkamFjZW50ICppdGVyOwogCkBAIC02NjU2LDcgKzY2MjcsNyBAQAogCWlmICghcXVldWUpCiAJCXJldHVybiBOVUxMOwogCW5ldGRldl9pbml0X29uZV9xdWV1ZShkZXYsIHF1ZXVlLCBOVUxMKTsKLQlxdWV1ZS0+cWRpc2MgPSAmbm9vcF9xZGlzYzsKKwlSQ1VfSU5JVF9QT0lOVEVSKHF1ZXVlLT5xZGlzYywgJm5vb3BfcWRpc2MpOwogCXF1ZXVlLT5xZGlzY19zbGVlcGluZyA9ICZub29wX3FkaXNjOwogCXJjdV9hc3NpZ25fcG9pbnRlcihkZXYtPmluZ3Jlc3NfcXVldWUsIHF1ZXVlKTsKICNlbmRpZgpAQCAtNzA3MiwxMCArNzA0MywyMCBAQAogCQlvbGRzZC0+b3V0cHV0X3F1ZXVlID0gTlVMTDsKIAkJb2xkc2QtPm91dHB1dF9xdWV1ZV90YWlscCA9ICZvbGRzZC0+b3V0cHV0X3F1ZXVlOwogCX0KLQkvKiBBcHBlbmQgTkFQSSBwb2xsIGxpc3QgZnJvbSBvZmZsaW5lIENQVS4gKi8KLQlpZiAoIWxpc3RfZW1wdHkoJm9sZHNkLT5wb2xsX2xpc3QpKSB7Ci0JCWxpc3Rfc3BsaWNlX2luaXQoJm9sZHNkLT5wb2xsX2xpc3QsICZzZC0+cG9sbF9saXN0KTsKLQkJcmFpc2Vfc29mdGlycV9pcnFvZmYoTkVUX1JYX1NPRlRJUlEpOworCS8qIEFwcGVuZCBOQVBJIHBvbGwgbGlzdCBmcm9tIG9mZmxpbmUgQ1BVLCB3aXRoIG9uZSBleGNlcHRpb24gOgorCSAqIHByb2Nlc3NfYmFja2xvZygpIG11c3QgYmUgY2FsbGVkIGJ5IGNwdSBvd25pbmcgcGVyY3B1IGJhY2tsb2cuCisJICogV2UgcHJvcGVybHkgaGFuZGxlIHByb2Nlc3NfcXVldWUgJiBpbnB1dF9wa3RfcXVldWUgbGF0ZXIuCisJICovCisJd2hpbGUgKCFsaXN0X2VtcHR5KCZvbGRzZC0+cG9sbF9saXN0KSkgeworCQlzdHJ1Y3QgbmFwaV9zdHJ1Y3QgKm5hcGkgPSBsaXN0X2ZpcnN0X2VudHJ5KCZvbGRzZC0+cG9sbF9saXN0LAorCQkJCQkJCSAgICBzdHJ1Y3QgbmFwaV9zdHJ1Y3QsCisJCQkJCQkJICAgIHBvbGxfbGlzdCk7CisKKwkJbGlzdF9kZWxfaW5pdCgmbmFwaS0+cG9sbF9saXN0KTsKKwkJaWYgKG5hcGktPnBvbGwgPT0gcHJvY2Vzc19iYWNrbG9nKQorCQkJbmFwaS0+c3RhdGUgPSAwOworCQllbHNlCisJCQlfX19fbmFwaV9zY2hlZHVsZShzZCwgbmFwaSk7CiAJfQogCiAJcmFpc2Vfc29mdGlycV9pcnFvZmYoTkVUX1RYX1NPRlRJUlEpOwpAQCAtNzA4Niw3ICs3MDY3LDcgQEAKIAkJbmV0aWZfcnhfaW50ZXJuYWwoc2tiKTsKIAkJaW5wdXRfcXVldWVfaGVhZF9pbmNyKG9sZHNkKTsKIAl9Ci0Jd2hpbGUgKChza2IgPSBfX3NrYl9kZXF1ZXVlKCZvbGRzZC0+aW5wdXRfcGt0X3F1ZXVlKSkpIHsKKwl3aGlsZSAoKHNrYiA9IHNrYl9kZXF1ZXVlKCZvbGRzZC0+aW5wdXRfcGt0X3F1ZXVlKSkpIHsKIAkJbmV0aWZfcnhfaW50ZXJuYWwoc2tiKTsKIAkJaW5wdXRfcXVldWVfaGVhZF9pbmNyKG9sZHNkKTsKIAl9CmRpZmYgLS1naXQgYS9uZXQvY29yZS9ydG5ldGxpbmsuYyBiL25ldC9jb3JlL3J0bmV0bGluay5jCmluZGV4IDljZjZmZTkuLjQ0NmNiYWYgMTAwNjQ0Ci0tLSBhL25ldC9jb3JlL3J0bmV0bGluay5jCisrKyBiL25ldC9jb3JlL3J0bmV0bGluay5jCkBAIC0yODk1LDEyICsyODk1LDE2IEBACiAJCQlnb3RvIGVycm91dDsKIAl9CiAKKwlpZiAoIXNrYi0+bGVuKQorCQlnb3RvIGVycm91dDsKKwogCXJ0bmxfbm90aWZ5KHNrYiwgbmV0LCAwLCBSVE5MR1JQX0xJTkssIE5VTEwsIEdGUF9BVE9NSUMpOwogCXJldHVybiAwOwogZXJyb3V0OgogCVdBUk5fT04oZXJyID09IC1FTVNHU0laRSk7CiAJa2ZyZWVfc2tiKHNrYik7Ci0JcnRubF9zZXRfc2tfZXJyKG5ldCwgUlROTEdSUF9MSU5LLCBlcnIpOworCWlmIChlcnIpCisJCXJ0bmxfc2V0X3NrX2VycihuZXQsIFJUTkxHUlBfTElOSywgZXJyKTsKIAlyZXR1cm4gZXJyOwogfQogCmRpZmYgLS1naXQgYS9uZXQvZHNhL3NsYXZlLmMgYi9uZXQvZHNhL3NsYXZlLmMKaW5kZXggNTE1NTY5Zi4uNTg5YWFmZCAxMDA2NDQKLS0tIGEvbmV0L2RzYS9zbGF2ZS5jCisrKyBiL25ldC9kc2Evc2xhdmUuYwpAQCAtNDYsNiArNDYsNyBAQAogCXNucHJpbnRmKGRzLT5zbGF2ZV9taWlfYnVzLT5pZCwgTUlJX0JVU19JRF9TSVpFLCAiZHNhLSVkOiUuMngiLAogCQkJZHMtPmluZGV4LCBkcy0+cGQtPnN3X2FkZHIpOwogCWRzLT5zbGF2ZV9taWlfYnVzLT5wYXJlbnQgPSBkcy0+bWFzdGVyX2RldjsKKwlkcy0+c2xhdmVfbWlpX2J1cy0+cGh5X21hc2sgPSB+ZHMtPnBoeXNfbWlpX21hc2s7CiB9CiAKIApkaWZmIC0tZ2l0IGEvbmV0L2lwdjQvaXBfZm9yd2FyZC5jIGIvbmV0L2lwdjQvaXBfZm9yd2FyZC5jCmluZGV4IDNhODNjZTUuLjc4N2IzYzIgMTAwNjQ0Ci0tLSBhL25ldC9pcHY0L2lwX2ZvcndhcmQuYworKysgYi9uZXQvaXB2NC9pcF9mb3J3YXJkLmMKQEAgLTEyOSw3ICsxMjksOCBAQAogCSAqCVdlIG5vdyBnZW5lcmF0ZSBhbiBJQ01QIEhPU1QgUkVESVJFQ1QgZ2l2aW5nIHRoZSByb3V0ZQogCSAqCXdlIGNhbGN1bGF0ZWQuCiAJICovCi0JaWYgKHJ0LT5ydF9mbGFncyZSVENGX0RPUkVESVJFQ1QgJiYgIW9wdC0+c3JyICYmICFza2Jfc2VjX3BhdGgoc2tiKSkKKwlpZiAoSVBDQihza2IpLT5mbGFncyAmIElQU0tCX0RPUkVESVJFQ1QgJiYgIW9wdC0+c3JyICYmCisJICAgICFza2Jfc2VjX3BhdGgoc2tiKSkKIAkJaXBfcnRfc2VuZF9yZWRpcmVjdChza2IpOwogCiAJc2tiLT5wcmlvcml0eSA9IHJ0X3RvczJwcmlvcml0eShpcGgtPnRvcyk7CmRpZmYgLS1naXQgYS9uZXQvaXB2NC9pcF9vdXRwdXQuYyBiL25ldC9pcHY0L2lwX291dHB1dC5jCmluZGV4IGI1MDg2MWIuLmMzNzNjMDcgMTAwNjQ0Ci0tLSBhL25ldC9pcHY0L2lwX291dHB1dC5jCisrKyBiL25ldC9pcHY0L2lwX291dHB1dC5jCkBAIC0xNTA2LDIzICsxNTA2LDggQEAKIC8qCiAgKglHZW5lcmljIGZ1bmN0aW9uIHRvIHNlbmQgYSBwYWNrZXQgYXMgcmVwbHkgdG8gYW5vdGhlciBwYWNrZXQuCiAgKglVc2VkIHRvIHNlbmQgc29tZSBUQ1AgcmVzZXRzL2Fja3Mgc28gZmFyLgotICoKLSAqCVVzZSBhIGZha2UgcGVyY3B1IGluZXQgc29ja2V0IHRvIGF2b2lkIGZhbHNlIHNoYXJpbmcgYW5kIGNvbnRlbnRpb24uCiAgKi8KLXN0YXRpYyBERUZJTkVfUEVSX0NQVShzdHJ1Y3QgaW5ldF9zb2NrLCB1bmljYXN0X3NvY2spID0gewotCS5zayA9IHsKLQkJLl9fc2tfY29tbW9uID0gewotCQkJLnNrY19yZWZjbnQgPSBBVE9NSUNfSU5JVCgxKSwKLQkJfSwKLQkJLnNrX3dtZW1fYWxsb2MJPSBBVE9NSUNfSU5JVCgxKSwKLQkJLnNrX2FsbG9jYXRpb24JPSBHRlBfQVRPTUlDLAotCQkuc2tfZmxhZ3MJPSAoMVVMIDw8IFNPQ0tfVVNFX1dSSVRFX1FVRVVFKSwKLQl9LAotCS5wbXR1ZGlzYwk9IElQX1BNVFVESVNDX1dBTlQsCi0JLnVjX3R0bAkJPSAtMSwKLX07Ci0KLXZvaWQgaXBfc2VuZF91bmljYXN0X3JlcGx5KHN0cnVjdCBuZXQgKm5ldCwgc3RydWN0IHNrX2J1ZmYgKnNrYiwKK3ZvaWQgaXBfc2VuZF91bmljYXN0X3JlcGx5KHN0cnVjdCBzb2NrICpzaywgc3RydWN0IHNrX2J1ZmYgKnNrYiwKIAkJCSAgIGNvbnN0IHN0cnVjdCBpcF9vcHRpb25zICpzb3B0LAogCQkJICAgX19iZTMyIGRhZGRyLCBfX2JlMzIgc2FkZHIsCiAJCQkgICBjb25zdCBzdHJ1Y3QgaXBfcmVwbHlfYXJnICphcmcsCkBAIC0xNTMyLDkgKzE1MTcsOCBAQAogCXN0cnVjdCBpcGNtX2Nvb2tpZSBpcGM7CiAJc3RydWN0IGZsb3dpNCBmbDQ7CiAJc3RydWN0IHJ0YWJsZSAqcnQgPSBza2JfcnRhYmxlKHNrYik7CisJc3RydWN0IG5ldCAqbmV0ID0gc29ja19uZXQoc2spOwogCXN0cnVjdCBza19idWZmICpuc2tiOwotCXN0cnVjdCBzb2NrICpzazsKLQlzdHJ1Y3QgaW5ldF9zb2NrICppbmV0OwogCWludCBlcnI7CiAKIAlpZiAoX19pcF9vcHRpb25zX2VjaG8oJnJlcGx5b3B0cy5vcHQub3B0LCBza2IsIHNvcHQpKQpAQCAtMTU2NSwxNSArMTU0OSwxMSBAQAogCWlmIChJU19FUlIocnQpKQogCQlyZXR1cm47CiAKLQlpbmV0ID0gJmdldF9jcHVfdmFyKHVuaWNhc3Rfc29jayk7CisJaW5ldF9zayhzayktPnRvcyA9IGFyZy0+dG9zOwogCi0JaW5ldC0+dG9zID0gYXJnLT50b3M7Ci0Jc2sgPSAmaW5ldC0+c2s7CiAJc2stPnNrX3ByaW9yaXR5ID0gc2tiLT5wcmlvcml0eTsKIAlzay0+c2tfcHJvdG9jb2wgPSBpcF9oZHIoc2tiKS0+cHJvdG9jb2w7CiAJc2stPnNrX2JvdW5kX2Rldl9pZiA9IGFyZy0+Ym91bmRfZGV2X2lmOwotCXNvY2tfbmV0X3NldChzaywgbmV0KTsKLQlfX3NrYl9xdWV1ZV9oZWFkX2luaXQoJnNrLT5za193cml0ZV9xdWV1ZSk7CiAJc2stPnNrX3NuZGJ1ZiA9IHN5c2N0bF93bWVtX2RlZmF1bHQ7CiAJZXJyID0gaXBfYXBwZW5kX2RhdGEoc2ssICZmbDQsIGlwX3JlcGx5X2dsdWVfYml0cywgYXJnLT5pb3YtPmlvdl9iYXNlLAogCQkJICAgICBsZW4sIDAsICZpcGMsICZydCwgTVNHX0RPTlRXQUlUKTsKQEAgLTE1ODksMTMgKzE1NjksMTAgQEAKIAkJCSAgYXJnLT5jc3Vtb2Zmc2V0KSA9IGNzdW1fZm9sZChjc3VtX2FkZChuc2tiLT5jc3VtLAogCQkJCQkJCQlhcmctPmNzdW0pKTsKIAkJbnNrYi0+aXBfc3VtbWVkID0gQ0hFQ0tTVU1fTk9ORTsKLQkJc2tiX29ycGhhbihuc2tiKTsKIAkJc2tiX3NldF9xdWV1ZV9tYXBwaW5nKG5za2IsIHNrYl9nZXRfcXVldWVfbWFwcGluZyhza2IpKTsKIAkJaXBfcHVzaF9wZW5kaW5nX2ZyYW1lcyhzaywgJmZsNCk7CiAJfQogb3V0OgotCXB1dF9jcHVfdmFyKHVuaWNhc3Rfc29jayk7Ci0KIAlpcF9ydF9wdXQocnQpOwogfQogCmRpZmYgLS1naXQgYS9uZXQvaXB2NC9pcF9zb2NrZ2x1ZS5jIGIvbmV0L2lwdjQvaXBfc29ja2dsdWUuYwppbmRleCA4YTg5YzczLi42Yjg1YWRiIDEwMDY0NAotLS0gYS9uZXQvaXB2NC9pcF9zb2NrZ2x1ZS5jCisrKyBiL25ldC9pcHY0L2lwX3NvY2tnbHVlLmMKQEAgLTQ2MSwxNyArNDYxLDEzIEBACiAKIAltZW1jcHkoJmVycmhkci5lZSwgJnNlcnItPmVlLCBzaXplb2Yoc3RydWN0IHNvY2tfZXh0ZW5kZWRfZXJyKSk7CiAJc2luID0gJmVycmhkci5vZmZlbmRlcjsKLQlzaW4tPnNpbl9mYW1pbHkgPSBBRl9VTlNQRUM7CisJbWVtc2V0KHNpbiwgMCwgc2l6ZW9mKCpzaW4pKTsKIAogCWlmIChzZXJyLT5lZS5lZV9vcmlnaW4gPT0gU09fRUVfT1JJR0lOX0lDTVAgfHwKIAkgICAgaXB2NF9wa3RpbmZvX3ByZXBhcmVfZXJycXVldWUoc2ssIHNrYiwgc2Vyci0+ZWUuZWVfb3JpZ2luKSkgewotCQlzdHJ1Y3QgaW5ldF9zb2NrICppbmV0ID0gaW5ldF9zayhzayk7Ci0KIAkJc2luLT5zaW5fZmFtaWx5ID0gQUZfSU5FVDsKIAkJc2luLT5zaW5fYWRkci5zX2FkZHIgPSBpcF9oZHIoc2tiKS0+c2FkZHI7Ci0JCXNpbi0+c2luX3BvcnQgPSAwOwotCQltZW1zZXQoJnNpbi0+c2luX3plcm8sIDAsIHNpemVvZihzaW4tPnNpbl96ZXJvKSk7Ci0JCWlmIChpbmV0LT5jbXNnX2ZsYWdzKQorCQlpZiAoaW5ldF9zayhzayktPmNtc2dfZmxhZ3MpCiAJCQlpcF9jbXNnX3JlY3YobXNnLCBza2IpOwogCX0KIApkaWZmIC0tZ2l0IGEvbmV0L2lwdjQvcGluZy5jIGIvbmV0L2lwdjQvcGluZy5jCmluZGV4IGMwZDgyZjcuLjJhMzcyMGYgMTAwNjQ0Ci0tLSBhL25ldC9pcHY0L3BpbmcuYworKysgYi9uZXQvaXB2NC9waW5nLmMKQEAgLTk2Niw4ICs5NjYsMTEgQEAKIAogCXNrID0gcGluZ19sb29rdXAobmV0LCBza2IsIG50b2hzKGljbXBoLT51bi5lY2hvLmlkKSk7CiAJaWYgKHNrICE9IE5VTEwpIHsKKwkJc3RydWN0IHNrX2J1ZmYgKnNrYjIgPSBza2JfY2xvbmUoc2tiLCBHRlBfQVRPTUlDKTsKKwogCQlwcl9kZWJ1ZygicmN2IG9uIHNvY2tldCAlcFxuIiwgc2spOwotCQlwaW5nX3F1ZXVlX3Jjdl9za2Ioc2ssIHNrYl9nZXQoc2tiKSk7CisJCWlmIChza2IyKQorCQkJcGluZ19xdWV1ZV9yY3Zfc2tiKHNrLCBza2IyKTsKIAkJc29ja19wdXQoc2spOwogCQlyZXR1cm4gdHJ1ZTsKIAl9CmRpZmYgLS1naXQgYS9uZXQvaXB2NC9yb3V0ZS5jIGIvbmV0L2lwdjQvcm91dGUuYwppbmRleCA2YTIxNTViLi41MmUxZjJiIDEwMDY0NAotLS0gYS9uZXQvaXB2NC9yb3V0ZS5jCisrKyBiL25ldC9pcHY0L3JvdXRlLmMKQEAgLTk2Niw2ICs5NjYsOSBAQAogCWlmIChkc3QtPmRldi0+bXR1IDwgbXR1KQogCQlyZXR1cm47CiAKKwlpZiAocnQtPnJ0X3BtdHUgJiYgcnQtPnJ0X3BtdHUgPCBtdHUpCisJCXJldHVybjsKKwogCWlmIChtdHUgPCBpcF9ydF9taW5fcG10dSkKIAkJbXR1ID0gaXBfcnRfbWluX3BtdHU7CiAKQEAgLTE1NTQsMTEgKzE1NTcsMTAgQEAKIAogCWRvX2NhY2hlID0gcmVzLT5maSAmJiAhaXRhZzsKIAlpZiAob3V0X2RldiA9PSBpbl9kZXYgJiYgZXJyICYmIElOX0RFVl9UWF9SRURJUkVDVFMob3V0X2RldikgJiYKKwkgICAgc2tiLT5wcm90b2NvbCA9PSBodG9ucyhFVEhfUF9JUCkgJiYKIAkgICAgKElOX0RFVl9TSEFSRURfTUVESUEob3V0X2RldikgfHwKLQkgICAgIGluZXRfYWRkcl9vbmxpbmsob3V0X2Rldiwgc2FkZHIsIEZJQl9SRVNfR1coKnJlcykpKSkgewotCQlmbGFncyB8PSBSVENGX0RPUkVESVJFQ1Q7Ci0JCWRvX2NhY2hlID0gZmFsc2U7Ci0JfQorCSAgICAgaW5ldF9hZGRyX29ubGluayhvdXRfZGV2LCBzYWRkciwgRklCX1JFU19HVygqcmVzKSkpKQorCQlJUENCKHNrYiktPmZsYWdzIHw9IElQU0tCX0RPUkVESVJFQ1Q7CiAKIAlpZiAoc2tiLT5wcm90b2NvbCAhPSBodG9ucyhFVEhfUF9JUCkpIHsKIAkJLyogTm90IElQIChpLmUuIEFSUCkuIERvIG5vdCBjcmVhdGUgcm91dGUsIGlmIGl0IGlzCkBAIC0yMzAzLDYgKzIzMDUsOCBAQAogCXItPnJ0bV9mbGFncwk9IChydC0+cnRfZmxhZ3MgJiB+MHhGRkZGKSB8IFJUTV9GX0NMT05FRDsKIAlpZiAocnQtPnJ0X2ZsYWdzICYgUlRDRl9OT1RJRlkpCiAJCXItPnJ0bV9mbGFncyB8PSBSVE1fRl9OT1RJRlk7CisJaWYgKElQQ0Ioc2tiKS0+ZmxhZ3MgJiBJUFNLQl9ET1JFRElSRUNUKQorCQlyLT5ydG1fZmxhZ3MgfD0gUlRDRl9ET1JFRElSRUNUOwogCiAJaWYgKG5sYV9wdXRfYmUzMihza2IsIFJUQV9EU1QsIGRzdCkpCiAJCWdvdG8gbmxhX3B1dF9mYWlsdXJlOwpkaWZmIC0tZ2l0IGEvbmV0L2lwdjQvdGNwX2JpYy5jIGIvbmV0L2lwdjQvdGNwX2JpYy5jCmluZGV4IGJiMzk1ZDQuLmMwMzc2NDQgMTAwNjQ0Ci0tLSBhL25ldC9pcHY0L3RjcF9iaWMuYworKysgYi9uZXQvaXB2NC90Y3BfYmljLmMKQEAgLTE1MCw3ICsxNTAsNyBAQAogCQl0Y3Bfc2xvd19zdGFydCh0cCwgYWNrZWQpOwogCWVsc2UgewogCQliaWN0Y3BfdXBkYXRlKGNhLCB0cC0+c25kX2N3bmQpOwotCQl0Y3BfY29uZ19hdm9pZF9haSh0cCwgY2EtPmNudCk7CisJCXRjcF9jb25nX2F2b2lkX2FpKHRwLCBjYS0+Y250LCAxKTsKIAl9CiB9CiAKZGlmZiAtLWdpdCBhL25ldC9pcHY0L3RjcF9jb25nLmMgYi9uZXQvaXB2NC90Y3BfY29uZy5jCmluZGV4IDI3ZWFkMGQuLjg2NzBlNjggMTAwNjQ0Ci0tLSBhL25ldC9pcHY0L3RjcF9jb25nLmMKKysrIGIvbmV0L2lwdjQvdGNwX2NvbmcuYwpAQCAtMjkxLDI2ICsyOTEsMzIgQEAKICAqIEFCQyBjYXBzIE4gdG8gMi4gU2xvdyBzdGFydCBleGl0cyB3aGVuIGN3bmQgZ3Jvd3Mgb3ZlciBzc3RocmVzaCBhbmQKICAqIHJldHVybnMgdGhlIGxlZnRvdmVyIGFja3MgdG8gYWRqdXN0IGN3bmQgaW4gY29uZ2VzdGlvbiBhdm9pZGFuY2UgbW9kZS4KICAqLwotdm9pZCB0Y3Bfc2xvd19zdGFydChzdHJ1Y3QgdGNwX3NvY2sgKnRwLCB1MzIgYWNrZWQpCit1MzIgdGNwX3Nsb3dfc3RhcnQoc3RydWN0IHRjcF9zb2NrICp0cCwgdTMyIGFja2VkKQogewogCXUzMiBjd25kID0gdHAtPnNuZF9jd25kICsgYWNrZWQ7CiAKIAlpZiAoY3duZCA+IHRwLT5zbmRfc3N0aHJlc2gpCiAJCWN3bmQgPSB0cC0+c25kX3NzdGhyZXNoICsgMTsKKwlhY2tlZCAtPSBjd25kIC0gdHAtPnNuZF9jd25kOwogCXRwLT5zbmRfY3duZCA9IG1pbihjd25kLCB0cC0+c25kX2N3bmRfY2xhbXApOworCisJcmV0dXJuIGFja2VkOwogfQogRVhQT1JUX1NZTUJPTF9HUEwodGNwX3Nsb3dfc3RhcnQpOwogCi0vKiBJbiB0aGVvcnkgdGhpcyBpcyB0cC0+c25kX2N3bmQgKz0gMSAvIHRwLT5zbmRfY3duZCAob3IgYWx0ZXJuYXRpdmUgdykgKi8KLXZvaWQgdGNwX2NvbmdfYXZvaWRfYWkoc3RydWN0IHRjcF9zb2NrICp0cCwgdTMyIHcpCisvKiBJbiB0aGVvcnkgdGhpcyBpcyB0cC0+c25kX2N3bmQgKz0gMSAvIHRwLT5zbmRfY3duZCAob3IgYWx0ZXJuYXRpdmUgdyksCisgKiBmb3IgZXZlcnkgcGFja2V0IHRoYXQgd2FzIEFDS2VkLgorICovCit2b2lkIHRjcF9jb25nX2F2b2lkX2FpKHN0cnVjdCB0Y3Bfc29jayAqdHAsIHUzMiB3LCB1MzIgYWNrZWQpCiB7CisJdHAtPnNuZF9jd25kX2NudCArPSBhY2tlZDsKIAlpZiAodHAtPnNuZF9jd25kX2NudCA+PSB3KSB7Ci0JCWlmICh0cC0+c25kX2N3bmQgPCB0cC0+c25kX2N3bmRfY2xhbXApCi0JCQl0cC0+c25kX2N3bmQrKzsKLQkJdHAtPnNuZF9jd25kX2NudCA9IDA7Ci0JfSBlbHNlIHsKLQkJdHAtPnNuZF9jd25kX2NudCsrOworCQl1MzIgZGVsdGEgPSB0cC0+c25kX2N3bmRfY250IC8gdzsKKworCQl0cC0+c25kX2N3bmRfY250IC09IGRlbHRhICogdzsKKwkJdHAtPnNuZF9jd25kICs9IGRlbHRhOwogCX0KKwl0cC0+c25kX2N3bmQgPSBtaW4odHAtPnNuZF9jd25kLCB0cC0+c25kX2N3bmRfY2xhbXApOwogfQogRVhQT1JUX1NZTUJPTF9HUEwodGNwX2NvbmdfYXZvaWRfYWkpOwogCkBAIC0zMjksMTEgKzMzNSwxMyBAQAogCQlyZXR1cm47CiAKIAkvKiBJbiAic2FmZSIgYXJlYSwgaW5jcmVhc2UuICovCi0JaWYgKHRwLT5zbmRfY3duZCA8PSB0cC0+c25kX3NzdGhyZXNoKQotCQl0Y3Bfc2xvd19zdGFydCh0cCwgYWNrZWQpOworCWlmICh0cC0+c25kX2N3bmQgPD0gdHAtPnNuZF9zc3RocmVzaCkgeworCQlhY2tlZCA9IHRjcF9zbG93X3N0YXJ0KHRwLCBhY2tlZCk7CisJCWlmICghYWNrZWQpCisJCQlyZXR1cm47CisJfQogCS8qIEluIGRhbmdlcm91cyBhcmVhLCBpbmNyZWFzZSBzbG93bHkuICovCi0JZWxzZQotCQl0Y3BfY29uZ19hdm9pZF9haSh0cCwgdHAtPnNuZF9jd25kKTsKKwl0Y3BfY29uZ19hdm9pZF9haSh0cCwgdHAtPnNuZF9jd25kLCBhY2tlZCk7CiB9CiBFWFBPUlRfU1lNQk9MX0dQTCh0Y3BfcmVub19jb25nX2F2b2lkKTsKIApkaWZmIC0tZ2l0IGEvbmV0L2lwdjQvdGNwX2N1YmljLmMgYi9uZXQvaXB2NC90Y3BfY3ViaWMuYwppbmRleCA2YjYwMDI0Li40YjI3NmQxIDEwMDY0NAotLS0gYS9uZXQvaXB2NC90Y3BfY3ViaWMuYworKysgYi9uZXQvaXB2NC90Y3BfY3ViaWMuYwpAQCAtOTMsOSArOTMsNyBAQAogCXUzMgllcG9jaF9zdGFydDsJLyogYmVnaW5uaW5nIG9mIGFuIGVwb2NoICovCiAJdTMyCWFja19jbnQ7CS8qIG51bWJlciBvZiBhY2tzICovCiAJdTMyCXRjcF9jd25kOwkvKiBlc3RpbWF0ZWQgdGNwIGN3bmQgKi8KLSNkZWZpbmUgQUNLX1JBVElPX1NISUZUCTQKLSNkZWZpbmUgQUNLX1JBVElPX0xJTUlUICgzMnUgPDwgQUNLX1JBVElPX1NISUZUKQotCXUxNglkZWxheWVkX2FjazsJLyogZXN0aW1hdGUgdGhlIHJhdGlvIG9mIFBhY2tldHMvQUNLcyA8PCA0ICovCisJdTE2CXVudXNlZDsKIAl1OAlzYW1wbGVfY250OwkvKiBudW1iZXIgb2Ygc2FtcGxlcyB0byBkZWNpZGUgY3Vycl9ydHQgKi8KIAl1OAlmb3VuZDsJCS8qIHRoZSBleGl0IHBvaW50IGlzIGZvdW5kPyAqLwogCXUzMglyb3VuZF9zdGFydDsJLyogYmVnaW5uaW5nIG9mIGVhY2ggcm91bmQgKi8KQEAgLTExNCw3ICsxMTIsNiBAQAogCWNhLT5iaWNfSyA9IDA7CiAJY2EtPmRlbGF5X21pbiA9IDA7CiAJY2EtPmVwb2NoX3N0YXJ0ID0gMDsKLQljYS0+ZGVsYXllZF9hY2sgPSAyIDw8IEFDS19SQVRJT19TSElGVDsKIAljYS0+YWNrX2NudCA9IDA7CiAJY2EtPnRjcF9jd25kID0gMDsKIAljYS0+Zm91bmQgPSAwOwpAQCAtMjA1LDIzICsyMDIsMzAgQEAKIC8qCiAgKiBDb21wdXRlIGNvbmdlc3Rpb24gd2luZG93IHRvIHVzZS4KICAqLwotc3RhdGljIGlubGluZSB2b2lkIGJpY3RjcF91cGRhdGUoc3RydWN0IGJpY3RjcCAqY2EsIHUzMiBjd25kKQorc3RhdGljIGlubGluZSB2b2lkIGJpY3RjcF91cGRhdGUoc3RydWN0IGJpY3RjcCAqY2EsIHUzMiBjd25kLCB1MzIgYWNrZWQpCiB7CiAJdTMyIGRlbHRhLCBiaWNfdGFyZ2V0LCBtYXhfY250OwogCXU2NCBvZmZzLCB0OwogCi0JY2EtPmFja19jbnQrKzsJLyogY291bnQgdGhlIG51bWJlciBvZiBBQ0tzICovCisJY2EtPmFja19jbnQgKz0gYWNrZWQ7CS8qIGNvdW50IHRoZSBudW1iZXIgb2YgQUNLZWQgcGFja2V0cyAqLwogCiAJaWYgKGNhLT5sYXN0X2N3bmQgPT0gY3duZCAmJgogCSAgICAoczMyKSh0Y3BfdGltZV9zdGFtcCAtIGNhLT5sYXN0X3RpbWUpIDw9IEhaIC8gMzIpCiAJCXJldHVybjsKIAorCS8qIFRoZSBDVUJJQyBmdW5jdGlvbiBjYW4gdXBkYXRlIGNhLT5jbnQgYXQgbW9zdCBvbmNlIHBlciBqaWZmeS4KKwkgKiBPbiBhbGwgY3duZCByZWR1Y3Rpb24gZXZlbnRzLCBjYS0+ZXBvY2hfc3RhcnQgaXMgc2V0IHRvIDAsCisJICogd2hpY2ggd2lsbCBmb3JjZSBhIHJlY2FsY3VsYXRpb24gb2YgY2EtPmNudC4KKwkgKi8KKwlpZiAoY2EtPmVwb2NoX3N0YXJ0ICYmIHRjcF90aW1lX3N0YW1wID09IGNhLT5sYXN0X3RpbWUpCisJCWdvdG8gdGNwX2ZyaWVuZGxpbmVzczsKKwogCWNhLT5sYXN0X2N3bmQgPSBjd25kOwogCWNhLT5sYXN0X3RpbWUgPSB0Y3BfdGltZV9zdGFtcDsKIAogCWlmIChjYS0+ZXBvY2hfc3RhcnQgPT0gMCkgewogCQljYS0+ZXBvY2hfc3RhcnQgPSB0Y3BfdGltZV9zdGFtcDsJLyogcmVjb3JkIGJlZ2lubmluZyAqLwotCQljYS0+YWNrX2NudCA9IDE7CQkJLyogc3RhcnQgY291bnRpbmcgKi8KKwkJY2EtPmFja19jbnQgPSBhY2tlZDsJCQkvKiBzdGFydCBjb3VudGluZyAqLwogCQljYS0+dGNwX2N3bmQgPSBjd25kOwkJCS8qIHN5biB3aXRoIGN1YmljICovCiAKIAkJaWYgKGNhLT5sYXN0X21heF9jd25kIDw9IGN3bmQpIHsKQEAgLTI4Myw2ICsyODcsNyBAQAogCWlmIChjYS0+bGFzdF9tYXhfY3duZCA9PSAwICYmIGNhLT5jbnQgPiAyMCkKIAkJY2EtPmNudCA9IDIwOwkvKiBpbmNyZWFzZSBjd25kIDUlIHBlciBSVFQgKi8KIAordGNwX2ZyaWVuZGxpbmVzczoKIAkvKiBUQ1AgRnJpZW5kbHkgKi8KIAlpZiAodGNwX2ZyaWVuZGxpbmVzcykgewogCQl1MzIgc2NhbGUgPSBiZXRhX3NjYWxlOwpAQCAtMzAxLDcgKzMwNiw2IEBACiAJCX0KIAl9CiAKLQljYS0+Y250ID0gKGNhLT5jbnQgPDwgQUNLX1JBVElPX1NISUZUKSAvIGNhLT5kZWxheWVkX2FjazsKIAlpZiAoY2EtPmNudCA9PSAwKQkJCS8qIGNhbm5vdCBiZSB6ZXJvICovCiAJCWNhLT5jbnQgPSAxOwogfQpAQCAtMzE3LDExICszMjEsMTIgQEAKIAlpZiAodHAtPnNuZF9jd25kIDw9IHRwLT5zbmRfc3N0aHJlc2gpIHsKIAkJaWYgKGh5c3RhcnQgJiYgYWZ0ZXIoYWNrLCBjYS0+ZW5kX3NlcSkpCiAJCQliaWN0Y3BfaHlzdGFydF9yZXNldChzayk7Ci0JCXRjcF9zbG93X3N0YXJ0KHRwLCBhY2tlZCk7Ci0JfSBlbHNlIHsKLQkJYmljdGNwX3VwZGF0ZShjYSwgdHAtPnNuZF9jd25kKTsKLQkJdGNwX2NvbmdfYXZvaWRfYWkodHAsIGNhLT5jbnQpOworCQlhY2tlZCA9IHRjcF9zbG93X3N0YXJ0KHRwLCBhY2tlZCk7CisJCWlmICghYWNrZWQpCisJCQlyZXR1cm47CiAJfQorCWJpY3RjcF91cGRhdGUoY2EsIHRwLT5zbmRfY3duZCwgYWNrZWQpOworCXRjcF9jb25nX2F2b2lkX2FpKHRwLCBjYS0+Y250LCBhY2tlZCk7CiB9CiAKIHN0YXRpYyB1MzIgYmljdGNwX3JlY2FsY19zc3RocmVzaChzdHJ1Y3Qgc29jayAqc2spCkBAIC00MTEsMjAgKzQxNiwxMCBAQAogICovCiBzdGF0aWMgdm9pZCBiaWN0Y3BfYWNrZWQoc3RydWN0IHNvY2sgKnNrLCB1MzIgY250LCBzMzIgcnR0X3VzKQogewotCWNvbnN0IHN0cnVjdCBpbmV0X2Nvbm5lY3Rpb25fc29jayAqaWNzayA9IGluZXRfY3NrKHNrKTsKIAljb25zdCBzdHJ1Y3QgdGNwX3NvY2sgKnRwID0gdGNwX3NrKHNrKTsKIAlzdHJ1Y3QgYmljdGNwICpjYSA9IGluZXRfY3NrX2NhKHNrKTsKIAl1MzIgZGVsYXk7CiAKLQlpZiAoaWNzay0+aWNza19jYV9zdGF0ZSA9PSBUQ1BfQ0FfT3BlbikgewotCQl1MzIgcmF0aW8gPSBjYS0+ZGVsYXllZF9hY2s7Ci0KLQkJcmF0aW8gLT0gY2EtPmRlbGF5ZWRfYWNrID4+IEFDS19SQVRJT19TSElGVDsKLQkJcmF0aW8gKz0gY250OwotCi0JCWNhLT5kZWxheWVkX2FjayA9IGNsYW1wKHJhdGlvLCAxVSwgQUNLX1JBVElPX0xJTUlUKTsKLQl9Ci0KIAkvKiBTb21lIGNhbGxzIGFyZSBmb3IgZHVwbGljYXRlcyB3aXRob3V0IHRpbWV0YW1wcyAqLwogCWlmIChydHRfdXMgPCAwKQogCQlyZXR1cm47CmRpZmYgLS1naXQgYS9uZXQvaXB2NC90Y3BfaXB2NC5jIGIvbmV0L2lwdjQvdGNwX2lwdjQuYwppbmRleCBhM2Y3MmQ3Li5kMjJmNTQ0IDEwMDY0NAotLS0gYS9uZXQvaXB2NC90Y3BfaXB2NC5jCisrKyBiL25ldC9pcHY0L3RjcF9pcHY0LmMKQEAgLTY4Myw3ICs2ODMsOCBAQAogCQlhcmcuYm91bmRfZGV2X2lmID0gc2stPnNrX2JvdW5kX2Rldl9pZjsKIAogCWFyZy50b3MgPSBpcF9oZHIoc2tiKS0+dG9zOwotCWlwX3NlbmRfdW5pY2FzdF9yZXBseShuZXQsIHNrYiwgJlRDUF9TS0JfQ0Ioc2tiKS0+aGVhZGVyLmg0Lm9wdCwKKwlpcF9zZW5kX3VuaWNhc3RfcmVwbHkoKnRoaXNfY3B1X3B0cihuZXQtPmlwdjQudGNwX3NrKSwKKwkJCSAgICAgIHNrYiwgJlRDUF9TS0JfQ0Ioc2tiKS0+aGVhZGVyLmg0Lm9wdCwKIAkJCSAgICAgIGlwX2hkcihza2IpLT5zYWRkciwgaXBfaGRyKHNrYiktPmRhZGRyLAogCQkJICAgICAgJmFyZywgYXJnLmlvdlswXS5pb3ZfbGVuKTsKIApAQCAtNzY3LDcgKzc2OCw4IEBACiAJaWYgKG9pZikKIAkJYXJnLmJvdW5kX2Rldl9pZiA9IG9pZjsKIAlhcmcudG9zID0gdG9zOwotCWlwX3NlbmRfdW5pY2FzdF9yZXBseShuZXQsIHNrYiwgJlRDUF9TS0JfQ0Ioc2tiKS0+aGVhZGVyLmg0Lm9wdCwKKwlpcF9zZW5kX3VuaWNhc3RfcmVwbHkoKnRoaXNfY3B1X3B0cihuZXQtPmlwdjQudGNwX3NrKSwKKwkJCSAgICAgIHNrYiwgJlRDUF9TS0JfQ0Ioc2tiKS0+aGVhZGVyLmg0Lm9wdCwKIAkJCSAgICAgIGlwX2hkcihza2IpLT5zYWRkciwgaXBfaGRyKHNrYiktPmRhZGRyLAogCQkJICAgICAgJmFyZywgYXJnLmlvdlswXS5pb3ZfbGVuKTsKIApAQCAtMjQyOCwxNCArMjQzMCwzOSBAQAogfTsKIEVYUE9SVF9TWU1CT0wodGNwX3Byb3QpOwogCi1zdGF0aWMgaW50IF9fbmV0X2luaXQgdGNwX3NrX2luaXQoc3RydWN0IG5ldCAqbmV0KQotewotCW5ldC0+aXB2NC5zeXNjdGxfdGNwX2VjbiA9IDI7Ci0JcmV0dXJuIDA7Ci19Ci0KIHN0YXRpYyB2b2lkIF9fbmV0X2V4aXQgdGNwX3NrX2V4aXQoc3RydWN0IG5ldCAqbmV0KQogeworCWludCBjcHU7CisKKwlmb3JfZWFjaF9wb3NzaWJsZV9jcHUoY3B1KQorCQlpbmV0X2N0bF9zb2NrX2Rlc3Ryb3koKnBlcl9jcHVfcHRyKG5ldC0+aXB2NC50Y3Bfc2ssIGNwdSkpOworCWZyZWVfcGVyY3B1KG5ldC0+aXB2NC50Y3Bfc2spOworfQorCitzdGF0aWMgaW50IF9fbmV0X2luaXQgdGNwX3NrX2luaXQoc3RydWN0IG5ldCAqbmV0KQoreworCWludCByZXMsIGNwdTsKKworCW5ldC0+aXB2NC50Y3Bfc2sgPSBhbGxvY19wZXJjcHUoc3RydWN0IHNvY2sgKik7CisJaWYgKCFuZXQtPmlwdjQudGNwX3NrKQorCQlyZXR1cm4gLUVOT01FTTsKKworCWZvcl9lYWNoX3Bvc3NpYmxlX2NwdShjcHUpIHsKKwkJc3RydWN0IHNvY2sgKnNrOworCisJCXJlcyA9IGluZXRfY3RsX3NvY2tfY3JlYXRlKCZzaywgUEZfSU5FVCwgU09DS19SQVcsCisJCQkJCSAgIElQUFJPVE9fVENQLCBuZXQpOworCQlpZiAocmVzKQorCQkJZ290byBmYWlsOworCQkqcGVyX2NwdV9wdHIobmV0LT5pcHY0LnRjcF9zaywgY3B1KSA9IHNrOworCX0KKwluZXQtPmlwdjQuc3lzY3RsX3RjcF9lY24gPSAyOworCXJldHVybiAwOworCitmYWlsOgorCXRjcF9za19leGl0KG5ldCk7CisKKwlyZXR1cm4gcmVzOwogfQogCiBzdGF0aWMgdm9pZCBfX25ldF9leGl0IHRjcF9za19leGl0X2JhdGNoKHN0cnVjdCBsaXN0X2hlYWQgKm5ldF9leGl0X2xpc3QpCmRpZmYgLS1naXQgYS9uZXQvaXB2NC90Y3Bfc2NhbGFibGUuYyBiL25ldC9pcHY0L3RjcF9zY2FsYWJsZS5jCmluZGV4IDY4MjRhZmIuLjMzM2JjYjIgMTAwNjQ0Ci0tLSBhL25ldC9pcHY0L3RjcF9zY2FsYWJsZS5jCisrKyBiL25ldC9pcHY0L3RjcF9zY2FsYWJsZS5jCkBAIC0yNSw3ICsyNSw4IEBACiAJaWYgKHRwLT5zbmRfY3duZCA8PSB0cC0+c25kX3NzdGhyZXNoKQogCQl0Y3Bfc2xvd19zdGFydCh0cCwgYWNrZWQpOwogCWVsc2UKLQkJdGNwX2NvbmdfYXZvaWRfYWkodHAsIG1pbih0cC0+c25kX2N3bmQsIFRDUF9TQ0FMQUJMRV9BSV9DTlQpKTsKKwkJdGNwX2NvbmdfYXZvaWRfYWkodHAsIG1pbih0cC0+c25kX2N3bmQsIFRDUF9TQ0FMQUJMRV9BSV9DTlQpLAorCQkJCSAgMSk7CiB9CiAKIHN0YXRpYyB1MzIgdGNwX3NjYWxhYmxlX3NzdGhyZXNoKHN0cnVjdCBzb2NrICpzaykKZGlmZiAtLWdpdCBhL25ldC9pcHY0L3RjcF92ZW5vLmMgYi9uZXQvaXB2NC90Y3BfdmVuby5jCmluZGV4IGE0ZDJkMmQuLjExMjE1MWUgMTAwNjQ0Ci0tLSBhL25ldC9pcHY0L3RjcF92ZW5vLmMKKysrIGIvbmV0L2lwdjQvdGNwX3Zlbm8uYwpAQCAtMTU5LDcgKzE1OSw3IEBACiAJCQkJLyogSW4gdGhlICJub24tY29uZ2VzdGl2ZSBzdGF0ZSIsIGluY3JlYXNlIGN3bmQKIAkJCQkgKiAgZXZlcnkgcnR0LgogCQkJCSAqLwotCQkJCXRjcF9jb25nX2F2b2lkX2FpKHRwLCB0cC0+c25kX2N3bmQpOworCQkJCXRjcF9jb25nX2F2b2lkX2FpKHRwLCB0cC0+c25kX2N3bmQsIDEpOwogCQkJfSBlbHNlIHsKIAkJCQkvKiBJbiB0aGUgImNvbmdlc3RpdmUgc3RhdGUiLCBpbmNyZWFzZSBjd25kCiAJCQkJICogZXZlcnkgb3RoZXIgcnR0LgpkaWZmIC0tZ2l0IGEvbmV0L2lwdjQvdGNwX3llYWguYyBiL25ldC9pcHY0L3RjcF95ZWFoLmMKaW5kZXggY2Q3MjczMi4uMTdkMzU2NiAxMDA2NDQKLS0tIGEvbmV0L2lwdjQvdGNwX3llYWguYworKysgYi9uZXQvaXB2NC90Y3BfeWVhaC5jCkBAIC05Miw3ICs5Miw3IEBACiAKIAl9IGVsc2UgewogCQkvKiBSZW5vICovCi0JCXRjcF9jb25nX2F2b2lkX2FpKHRwLCB0cC0+c25kX2N3bmQpOworCQl0Y3BfY29uZ19hdm9pZF9haSh0cCwgdHAtPnNuZF9jd25kLCAxKTsKIAl9CiAKIAkvKiBUaGUga2V5IHBsYXllcnMgYXJlIHZfdmVnYXMuYmVnX3NuZF91bmEgYW5kIHZfYmVnX3NuZF9ueHQuCmRpZmYgLS1naXQgYS9uZXQvaXB2NC91ZHBfZGlhZy5jIGIvbmV0L2lwdjQvdWRwX2RpYWcuYwppbmRleCA3OTI3ZGIwLi40YTAwMGYxIDEwMDY0NAotLS0gYS9uZXQvaXB2NC91ZHBfZGlhZy5jCisrKyBiL25ldC9pcHY0L3VkcF9kaWFnLmMKQEAgLTk5LDExICs5OSwxMyBAQAogCXNfc2xvdCA9IGNiLT5hcmdzWzBdOwogCW51bSA9IHNfbnVtID0gY2ItPmFyZ3NbMV07CiAKLQlmb3IgKHNsb3QgPSBzX3Nsb3Q7IHNsb3QgPD0gdGFibGUtPm1hc2s7IG51bSA9IHNfbnVtID0gMCwgc2xvdCsrKSB7CisJZm9yIChzbG90ID0gc19zbG90OyBzbG90IDw9IHRhYmxlLT5tYXNrOyBzX251bSA9IDAsIHNsb3QrKykgewogCQlzdHJ1Y3Qgc29jayAqc2s7CiAJCXN0cnVjdCBobGlzdF9udWxsc19ub2RlICpub2RlOwogCQlzdHJ1Y3QgdWRwX2hzbG90ICpoc2xvdCA9ICZ0YWJsZS0+aGFzaFtzbG90XTsKIAorCQludW0gPSAwOworCiAJCWlmIChobGlzdF9udWxsc19lbXB0eSgmaHNsb3QtPmhlYWQpKQogCQkJY29udGludWU7CiAKZGlmZiAtLWdpdCBhL25ldC9pcHY2L2RhdGFncmFtLmMgYi9uZXQvaXB2Ni9kYXRhZ3JhbS5jCmluZGV4IDEwMGM1ODkuLjQ5ZjVlNzMgMTAwNjQ0Ci0tLSBhL25ldC9pcHY2L2RhdGFncmFtLmMKKysrIGIvbmV0L2lwdjYvZGF0YWdyYW0uYwpAQCAtMzkzLDExICszOTMsMTAgQEAKIAogCW1lbWNweSgmZXJyaGRyLmVlLCAmc2Vyci0+ZWUsIHNpemVvZihzdHJ1Y3Qgc29ja19leHRlbmRlZF9lcnIpKTsKIAlzaW4gPSAmZXJyaGRyLm9mZmVuZGVyOwotCXNpbi0+c2luNl9mYW1pbHkgPSBBRl9VTlNQRUM7CisJbWVtc2V0KHNpbiwgMCwgc2l6ZW9mKCpzaW4pKTsKKwogCWlmIChzZXJyLT5lZS5lZV9vcmlnaW4gIT0gU09fRUVfT1JJR0lOX0xPQ0FMKSB7CiAJCXNpbi0+c2luNl9mYW1pbHkgPSBBRl9JTkVUNjsKLQkJc2luLT5zaW42X2Zsb3dpbmZvID0gMDsKLQkJc2luLT5zaW42X3BvcnQgPSAwOwogCQlpZiAobnAtPnJ4b3B0LmFsbCkgewogCQkJaWYgKHNlcnItPmVlLmVlX29yaWdpbiAhPSBTT19FRV9PUklHSU5fSUNNUCAmJgogCQkJICAgIHNlcnItPmVlLmVlX29yaWdpbiAhPSBTT19FRV9PUklHSU5fSUNNUDYpCkBAIC00MTIsMTIgKzQxMSw5IEBACiAJCQkJaXB2Nl9pZmFjZV9zY29wZV9pZCgmc2luLT5zaW42X2FkZHIsCiAJCQkJCQkgICAgSVA2Q0Ioc2tiKS0+aWlmKTsKIAkJfSBlbHNlIHsKLQkJCXN0cnVjdCBpbmV0X3NvY2sgKmluZXQgPSBpbmV0X3NrKHNrKTsKLQogCQkJaXB2Nl9hZGRyX3NldF92NG1hcHBlZChpcF9oZHIoc2tiKS0+c2FkZHIsCiAJCQkJCSAgICAgICAmc2luLT5zaW42X2FkZHIpOwotCQkJc2luLT5zaW42X3Njb3BlX2lkID0gMDsKLQkJCWlmIChpbmV0LT5jbXNnX2ZsYWdzKQorCQkJaWYgKGluZXRfc2soc2spLT5jbXNnX2ZsYWdzKQogCQkJCWlwX2Ntc2dfcmVjdihtc2csIHNrYik7CiAJCX0KIAl9CmRpZmYgLS1naXQgYS9uZXQvaXB2Ni9pcDZfZmliLmMgYi9uZXQvaXB2Ni9pcDZfZmliLmMKaW5kZXggYjJkMTgzOC4uZjFjNmQ1ZSAxMDA2NDQKLS0tIGEvbmV0L2lwdjYvaXA2X2ZpYi5jCisrKyBiL25ldC9pcHY2L2lwNl9maWIuYwpAQCAtNjU5LDYgKzY1OSwyOSBAQAogCXJldHVybiAwOwogfQogCitzdGF0aWMgdm9pZCBmaWI2X3B1cmdlX3J0KHN0cnVjdCBydDZfaW5mbyAqcnQsIHN0cnVjdCBmaWI2X25vZGUgKmZuLAorCQkJICBzdHJ1Y3QgbmV0ICpuZXQpCit7CisJaWYgKGF0b21pY19yZWFkKCZydC0+cnQ2aV9yZWYpICE9IDEpIHsKKwkJLyogVGhpcyByb3V0ZSBpcyB1c2VkIGFzIGR1bW15IGFkZHJlc3MgaG9sZGVyIGluIHNvbWUgc3BsaXQKKwkJICogbm9kZXMuIEl0IGlzIG5vdCBsZWFrZWQsIGJ1dCBpdCBzdGlsbCBob2xkcyBvdGhlciByZXNvdXJjZXMsCisJCSAqIHdoaWNoIG11c3QgYmUgcmVsZWFzZWQgaW4gdGltZS4gU28sIHNjYW4gYXNjZW5kYW50IG5vZGVzCisJCSAqIGFuZCByZXBsYWNlIGR1bW15IHJlZmVyZW5jZXMgdG8gdGhpcyByb3V0ZSB3aXRoIHJlZmVyZW5jZXMKKwkJICogdG8gc3RpbGwgYWxpdmUgb25lcy4KKwkJICovCisJCXdoaWxlIChmbikgeworCQkJaWYgKCEoZm4tPmZuX2ZsYWdzICYgUlROX1JUSU5GTykgJiYgZm4tPmxlYWYgPT0gcnQpIHsKKwkJCQlmbi0+bGVhZiA9IGZpYjZfZmluZF9wcmVmaXgobmV0LCBmbik7CisJCQkJYXRvbWljX2luYygmZm4tPmxlYWYtPnJ0NmlfcmVmKTsKKwkJCQlydDZfcmVsZWFzZShydCk7CisJCQl9CisJCQlmbiA9IGZuLT5wYXJlbnQ7CisJCX0KKwkJLyogTm8gbW9yZSByZWZlcmVuY2VzIGFyZSBwb3NzaWJsZSBhdCB0aGlzIHBvaW50LiAqLworCQlCVUdfT04oYXRvbWljX3JlYWQoJnJ0LT5ydDZpX3JlZikgIT0gMSk7CisJfQorfQorCiAvKgogICoJSW5zZXJ0IHJvdXRpbmcgaW5mb3JtYXRpb24gaW4gYSBub2RlLgogICovCkBAIC04MDcsMTEgKzgzMCwxMiBAQAogCQlydC0+ZHN0LnJ0Nl9uZXh0ID0gaXRlci0+ZHN0LnJ0Nl9uZXh0OwogCQlhdG9taWNfaW5jKCZydC0+cnQ2aV9yZWYpOwogCQlpbmV0Nl9ydF9ub3RpZnkoUlRNX05FV1JPVVRFLCBydCwgaW5mbyk7Ci0JCXJ0Nl9yZWxlYXNlKGl0ZXIpOwogCQlpZiAoIShmbi0+Zm5fZmxhZ3MgJiBSVE5fUlRJTkZPKSkgewogCQkJaW5mby0+bmxfbmV0LT5pcHY2LnJ0Nl9zdGF0cy0+ZmliX3JvdXRlX25vZGVzKys7CiAJCQlmbi0+Zm5fZmxhZ3MgfD0gUlROX1JUSU5GTzsKIAkJfQorCQlmaWI2X3B1cmdlX3J0KGl0ZXIsIGZuLCBpbmZvLT5ubF9uZXQpOworCQlydDZfcmVsZWFzZShpdGVyKTsKIAl9CiAKIAlyZXR1cm4gMDsKQEAgLTEzMjIsMjQgKzEzNDYsNyBAQAogCQlmbiA9IGZpYjZfcmVwYWlyX3RyZWUobmV0LCBmbik7CiAJfQogCi0JaWYgKGF0b21pY19yZWFkKCZydC0+cnQ2aV9yZWYpICE9IDEpIHsKLQkJLyogVGhpcyByb3V0ZSBpcyB1c2VkIGFzIGR1bW15IGFkZHJlc3MgaG9sZGVyIGluIHNvbWUgc3BsaXQKLQkJICogbm9kZXMuIEl0IGlzIG5vdCBsZWFrZWQsIGJ1dCBpdCBzdGlsbCBob2xkcyBvdGhlciByZXNvdXJjZXMsCi0JCSAqIHdoaWNoIG11c3QgYmUgcmVsZWFzZWQgaW4gdGltZS4gU28sIHNjYW4gYXNjZW5kYW50IG5vZGVzCi0JCSAqIGFuZCByZXBsYWNlIGR1bW15IHJlZmVyZW5jZXMgdG8gdGhpcyByb3V0ZSB3aXRoIHJlZmVyZW5jZXMKLQkJICogdG8gc3RpbGwgYWxpdmUgb25lcy4KLQkJICovCi0JCXdoaWxlIChmbikgewotCQkJaWYgKCEoZm4tPmZuX2ZsYWdzICYgUlROX1JUSU5GTykgJiYgZm4tPmxlYWYgPT0gcnQpIHsKLQkJCQlmbi0+bGVhZiA9IGZpYjZfZmluZF9wcmVmaXgobmV0LCBmbik7Ci0JCQkJYXRvbWljX2luYygmZm4tPmxlYWYtPnJ0NmlfcmVmKTsKLQkJCQlydDZfcmVsZWFzZShydCk7Ci0JCQl9Ci0JCQlmbiA9IGZuLT5wYXJlbnQ7Ci0JCX0KLQkJLyogTm8gbW9yZSByZWZlcmVuY2VzIGFyZSBwb3NzaWJsZSBhdCB0aGlzIHBvaW50LiAqLwotCQlCVUdfT04oYXRvbWljX3JlYWQoJnJ0LT5ydDZpX3JlZikgIT0gMSk7Ci0JfQorCWZpYjZfcHVyZ2VfcnQocnQsIGZuLCBuZXQpOwogCiAJaW5ldDZfcnRfbm90aWZ5KFJUTV9ERUxST1VURSwgcnQsIGluZm8pOwogCXJ0Nl9yZWxlYXNlKHJ0KTsKZGlmZiAtLWdpdCBhL25ldC9pcHY2L2lwNl9ncmUuYyBiL25ldC9pcHY2L2lwNl9ncmUuYwppbmRleCAxM2NkYTRjLi4wMWNjYzI4IDEwMDY0NAotLS0gYS9uZXQvaXB2Ni9pcDZfZ3JlLmMKKysrIGIvbmV0L2lwdjYvaXA2X2dyZS5jCkBAIC00MTcsNyArNDE3LDcgQEAKIAkJaWYgKGNvZGUgPT0gSUNNUFY2X0hEUl9GSUVMRCkKIAkJCXRlbGkgPSBpcDZfdG5sX3BhcnNlX3Rsdl9lbmNfbGltKHNrYiwgc2tiLT5kYXRhKTsKIAotCQlpZiAodGVsaSAmJiB0ZWxpID09IGluZm8gLSAyKSB7CisJCWlmICh0ZWxpICYmIHRlbGkgPT0gYmUzMl90b19jcHUoaW5mbykgLSAyKSB7CiAJCQl0ZWwgPSAoc3RydWN0IGlwdjZfdGx2X3RubF9lbmNfbGltICopICZza2ItPmRhdGFbdGVsaV07CiAJCQlpZiAodGVsLT5lbmNhcF9saW1pdCA9PSAwKSB7CiAJCQkJbmV0X3dhcm5fcmF0ZWxpbWl0ZWQoIiVzOiBUb28gc21hbGwgZW5jYXBzdWxhdGlvbiBsaW1pdCBvciByb3V0aW5nIGxvb3AgaW4gdHVubmVsIVxuIiwKQEAgLTQyOSw3ICs0MjksNyBAQAogCQl9CiAJCWJyZWFrOwogCWNhc2UgSUNNUFY2X1BLVF9UT09CSUc6Ci0JCW10dSA9IGluZm8gLSBvZmZzZXQ7CisJCW10dSA9IGJlMzJfdG9fY3B1KGluZm8pIC0gb2Zmc2V0OwogCQlpZiAobXR1IDwgSVBWNl9NSU5fTVRVKQogCQkJbXR1ID0gSVBWNl9NSU5fTVRVOwogCQl0LT5kZXYtPm10dSA9IG10dTsKZGlmZiAtLWdpdCBhL25ldC9pcHY2L2lwNl9vdXRwdXQuYyBiL25ldC9pcHY2L2lwNl9vdXRwdXQuYwppbmRleCBjZTY5YTEyLi5kMjhmMmEyIDEwMDY0NAotLS0gYS9uZXQvaXB2Ni9pcDZfb3V0cHV0LmMKKysrIGIvbmV0L2lwdjYvaXA2X291dHB1dC5jCkBAIC01MzcsMjAgKzUzNyw2IEBACiAJc2tiX2NvcHlfc2VjbWFyayh0bywgZnJvbSk7CiB9CiAKLXN0YXRpYyB2b2lkIGlwdjZfc2VsZWN0X2lkZW50KHN0cnVjdCBmcmFnX2hkciAqZmhkciwgc3RydWN0IHJ0Nl9pbmZvICpydCkKLXsKLQlzdGF0aWMgdTMyIGlwNl9pZGVudHNfaGFzaHJuZCBfX3JlYWRfbW9zdGx5OwotCXUzMiBoYXNoLCBpZDsKLQotCW5ldF9nZXRfcmFuZG9tX29uY2UoJmlwNl9pZGVudHNfaGFzaHJuZCwgc2l6ZW9mKGlwNl9pZGVudHNfaGFzaHJuZCkpOwotCi0JaGFzaCA9IF9faXB2Nl9hZGRyX2poYXNoKCZydC0+cnQ2aV9kc3QuYWRkciwgaXA2X2lkZW50c19oYXNocm5kKTsKLQloYXNoID0gX19pcHY2X2FkZHJfamhhc2goJnJ0LT5ydDZpX3NyYy5hZGRyLCBoYXNoKTsKLQotCWlkID0gaXBfaWRlbnRzX3Jlc2VydmUoaGFzaCwgMSk7Ci0JZmhkci0+aWRlbnRpZmljYXRpb24gPSBodG9ubChpZCk7Ci19Ci0KIGludCBpcDZfZnJhZ21lbnQoc3RydWN0IHNrX2J1ZmYgKnNrYiwgaW50ICgqb3V0cHV0KShzdHJ1Y3Qgc2tfYnVmZiAqKSkKIHsKIAlzdHJ1Y3Qgc2tfYnVmZiAqZnJhZzsKZGlmZiAtLWdpdCBhL25ldC9pcHY2L291dHB1dF9jb3JlLmMgYi9uZXQvaXB2Ni9vdXRwdXRfY29yZS5jCmluZGV4IDk3ZjQxYTMuLjU0NTIwYTAgMTAwNjQ0Ci0tLSBhL25ldC9pcHY2L291dHB1dF9jb3JlLmMKKysrIGIvbmV0L2lwdjYvb3V0cHV0X2NvcmUuYwpAQCAtOSw2ICs5LDI0IEBACiAjaW5jbHVkZSA8bmV0L2FkZHJjb25mLmg+CiAjaW5jbHVkZSA8bmV0L3NlY3VyZV9zZXEuaD4KIAordTMyIF9faXB2Nl9zZWxlY3RfaWRlbnQodTMyIGhhc2hybmQsIHN0cnVjdCBpbjZfYWRkciAqZHN0LCBzdHJ1Y3QgaW42X2FkZHIgKnNyYykKK3sKKwl1MzIgaGFzaCwgaWQ7CisKKwloYXNoID0gX19pcHY2X2FkZHJfamhhc2goZHN0LCBoYXNocm5kKTsKKwloYXNoID0gX19pcHY2X2FkZHJfamhhc2goc3JjLCBoYXNoKTsKKworCS8qIFRyZWF0IGlkIG9mIDAgYXMgdW5zZXQgYW5kIGlmIHdlIGdldCAwIGJhY2sgZnJvbSBpcF9pZGVudHNfcmVzZXJ2ZSwKKwkgKiBzZXQgdGhlIGhpZ2h0IG9yZGVyIGluc3RlYWQgdGh1cyBtaW5pbWl6aW5nIHBvc3NpYmxlIGZ1dHVyZQorCSAqIGNvbGxpc2lvbnMuCisJICovCisJaWQgPSBpcF9pZGVudHNfcmVzZXJ2ZShoYXNoLCAxKTsKKwlpZiAodW5saWtlbHkoIWlkKSkKKwkJaWQgPSAxIDw8IDMxOworCisJcmV0dXJuIGlkOworfQorCiAvKiBUaGlzIGZ1bmN0aW9uIGV4aXN0cyBvbmx5IGZvciB0YXAgZHJpdmVycyB0aGF0IG11c3Qgc3VwcG9ydCBicm9rZW4KICAqIGNsaWVudHMgcmVxdWVzdGluZyBVRk8gd2l0aG91dCBzcGVjaWZ5aW5nIGFuIElQdjYgZnJhZ21lbnQgSUQuCiAgKgpAQCAtMjIsNyArNDAsNyBAQAogCXN0YXRpYyB1MzIgaXA2X3Byb3h5X2lkZW50c19oYXNocm5kIF9fcmVhZF9tb3N0bHk7CiAJc3RydWN0IGluNl9hZGRyIGJ1ZlsyXTsKIAlzdHJ1Y3QgaW42X2FkZHIgKmFkZHJzOwotCXUzMiBoYXNoLCBpZDsKKwl1MzIgaWQ7CiAKIAlhZGRycyA9IHNrYl9oZWFkZXJfcG9pbnRlcihza2IsCiAJCQkJICAgc2tiX25ldHdvcmtfb2Zmc2V0KHNrYikgKwpAQCAtMzQsMTQgKzUyLDI1IEBACiAJbmV0X2dldF9yYW5kb21fb25jZSgmaXA2X3Byb3h5X2lkZW50c19oYXNocm5kLAogCQkJICAgIHNpemVvZihpcDZfcHJveHlfaWRlbnRzX2hhc2hybmQpKTsKIAotCWhhc2ggPSBfX2lwdjZfYWRkcl9qaGFzaCgmYWRkcnNbMV0sIGlwNl9wcm94eV9pZGVudHNfaGFzaHJuZCk7Ci0JaGFzaCA9IF9faXB2Nl9hZGRyX2poYXNoKCZhZGRyc1swXSwgaGFzaCk7Ci0KLQlpZCA9IGlwX2lkZW50c19yZXNlcnZlKGhhc2gsIDEpOwotCXNrYl9zaGluZm8oc2tiKS0+aXA2X2ZyYWdfaWQgPSBodG9ubChpZCk7CisJaWQgPSBfX2lwdjZfc2VsZWN0X2lkZW50KGlwNl9wcm94eV9pZGVudHNfaGFzaHJuZCwKKwkJCQkgJmFkZHJzWzFdLCAmYWRkcnNbMF0pOworCXNrYl9zaGluZm8oc2tiKS0+aXA2X2ZyYWdfaWQgPSBpZDsKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKGlwdjZfcHJveHlfc2VsZWN0X2lkZW50KTsKIAordm9pZCBpcHY2X3NlbGVjdF9pZGVudChzdHJ1Y3QgZnJhZ19oZHIgKmZoZHIsIHN0cnVjdCBydDZfaW5mbyAqcnQpCit7CisJc3RhdGljIHUzMiBpcDZfaWRlbnRzX2hhc2hybmQgX19yZWFkX21vc3RseTsKKwl1MzIgaWQ7CisKKwluZXRfZ2V0X3JhbmRvbV9vbmNlKCZpcDZfaWRlbnRzX2hhc2hybmQsIHNpemVvZihpcDZfaWRlbnRzX2hhc2hybmQpKTsKKworCWlkID0gX19pcHY2X3NlbGVjdF9pZGVudChpcDZfaWRlbnRzX2hhc2hybmQsICZydC0+cnQ2aV9kc3QuYWRkciwKKwkJCQkgJnJ0LT5ydDZpX3NyYy5hZGRyKTsKKwlmaGRyLT5pZGVudGlmaWNhdGlvbiA9IGh0b25sKGlkKTsKK30KK0VYUE9SVF9TWU1CT0woaXB2Nl9zZWxlY3RfaWRlbnQpOworCiBpbnQgaXA2X2ZpbmRfMXN0ZnJhZ29wdChzdHJ1Y3Qgc2tfYnVmZiAqc2tiLCB1OCAqKm5leHRoZHIpCiB7CiAJdTE2IG9mZnNldCA9IHNpemVvZihzdHJ1Y3QgaXB2Nmhkcik7CmRpZmYgLS1naXQgYS9uZXQvaXB2Ni9yb3V0ZS5jIGIvbmV0L2lwdjYvcm91dGUuYwppbmRleCBjOTEwODMxLi40OTU5NjUzNSAxMDA2NDQKLS0tIGEvbmV0L2lwdjYvcm91dGUuYworKysgYi9uZXQvaXB2Ni9yb3V0ZS5jCkBAIC0xMTYwLDEyICsxMTYwLDkgQEAKIAkJc3RydWN0IG5ldCAqbmV0ID0gZGV2X25ldChkc3QtPmRldik7CiAKIAkJcnQ2LT5ydDZpX2ZsYWdzIHw9IFJURl9NT0RJRklFRDsKLQkJaWYgKG10dSA8IElQVjZfTUlOX01UVSkgewotCQkJdTMyIGZlYXR1cmVzID0gZHN0X21ldHJpYyhkc3QsIFJUQVhfRkVBVFVSRVMpOworCQlpZiAobXR1IDwgSVBWNl9NSU5fTVRVKQogCQkJbXR1ID0gSVBWNl9NSU5fTVRVOwotCQkJZmVhdHVyZXMgfD0gUlRBWF9GRUFUVVJFX0FMTEZSQUc7Ci0JCQlkc3RfbWV0cmljX3NldChkc3QsIFJUQVhfRkVBVFVSRVMsIGZlYXR1cmVzKTsKLQkJfQorCiAJCWRzdF9tZXRyaWNfc2V0KGRzdCwgUlRBWF9NVFUsIG10dSk7CiAJCXJ0Nl91cGRhdGVfZXhwaXJlcyhydDYsIG5ldC0+aXB2Ni5zeXNjdGwuaXA2X3J0X210dV9leHBpcmVzKTsKIAl9CkBAIC0xMjQ1LDEyICsxMjQyLDE2IEBACiAJCXJ0ID0gbmV0LT5pcHY2LmlwNl9udWxsX2VudHJ5OwogCWVsc2UgaWYgKHJ0LT5kc3QuZXJyb3IpIHsKIAkJcnQgPSBuZXQtPmlwdjYuaXA2X251bGxfZW50cnk7Ci0JfSBlbHNlIGlmIChydCA9PSBuZXQtPmlwdjYuaXA2X251bGxfZW50cnkpIHsKKwkJZ290byBvdXQ7CisJfQorCisJaWYgKHJ0ID09IG5ldC0+aXB2Ni5pcDZfbnVsbF9lbnRyeSkgewogCQlmbiA9IGZpYjZfYmFja3RyYWNrKGZuLCAmZmw2LT5zYWRkcik7CiAJCWlmIChmbikKIAkJCWdvdG8gcmVzdGFydDsKIAl9CiAKK291dDoKIAlkc3RfaG9sZCgmcnQtPmRzdCk7CiAKIAlyZWFkX3VubG9ja19iaCgmdGFibGUtPnRiNl9sb2NrKTsKZGlmZiAtLWdpdCBhL25ldC9pcHY2L3NpdC5jIGIvbmV0L2lwdjYvc2l0LmMKaW5kZXggMjEzNTQ2Yi4uY2RiZmU1YSAxMDA2NDQKLS0tIGEvbmV0L2lwdjYvc2l0LmMKKysrIGIvbmV0L2lwdjYvc2l0LmMKQEAgLTE1MDYsMTIgKzE1MDYsMTIgQEAKIAogCWlmIChkYXRhW0lGTEFfSVBUVU5fRU5DQVBfU1BPUlRdKSB7CiAJCXJldCA9IHRydWU7Ci0JCWlwZW5jYXAtPnNwb3J0ID0gbmxhX2dldF91MTYoZGF0YVtJRkxBX0lQVFVOX0VOQ0FQX1NQT1JUXSk7CisJCWlwZW5jYXAtPnNwb3J0ID0gbmxhX2dldF9iZTE2KGRhdGFbSUZMQV9JUFRVTl9FTkNBUF9TUE9SVF0pOwogCX0KIAogCWlmIChkYXRhW0lGTEFfSVBUVU5fRU5DQVBfRFBPUlRdKSB7CiAJCXJldCA9IHRydWU7Ci0JCWlwZW5jYXAtPmRwb3J0ID0gbmxhX2dldF91MTYoZGF0YVtJRkxBX0lQVFVOX0VOQ0FQX0RQT1JUXSk7CisJCWlwZW5jYXAtPmRwb3J0ID0gbmxhX2dldF9iZTE2KGRhdGFbSUZMQV9JUFRVTl9FTkNBUF9EUE9SVF0pOwogCX0KIAogCXJldHVybiByZXQ7CkBAIC0xNzA3LDkgKzE3MDcsOSBAQAogCiAJaWYgKG5sYV9wdXRfdTE2KHNrYiwgSUZMQV9JUFRVTl9FTkNBUF9UWVBFLAogCQkJdHVubmVsLT5lbmNhcC50eXBlKSB8fAotCSAgICBubGFfcHV0X3UxNihza2IsIElGTEFfSVBUVU5fRU5DQVBfU1BPUlQsCisJICAgIG5sYV9wdXRfYmUxNihza2IsIElGTEFfSVBUVU5fRU5DQVBfU1BPUlQsCiAJCQl0dW5uZWwtPmVuY2FwLnNwb3J0KSB8fAotCSAgICBubGFfcHV0X3UxNihza2IsIElGTEFfSVBUVU5fRU5DQVBfRFBPUlQsCisJICAgIG5sYV9wdXRfYmUxNihza2IsIElGTEFfSVBUVU5fRU5DQVBfRFBPUlQsCiAJCQl0dW5uZWwtPmVuY2FwLmRwb3J0KSB8fAogCSAgICBubGFfcHV0X3UxNihza2IsIElGTEFfSVBUVU5fRU5DQVBfRkxBR1MsCiAJCQl0dW5uZWwtPmVuY2FwLmZsYWdzKSkKZGlmZiAtLWdpdCBhL25ldC9pcHY2L3VkcF9vZmZsb2FkLmMgYi9uZXQvaXB2Ni91ZHBfb2ZmbG9hZC5jCmluZGV4IGI2YWE4ZWQuLmE1NjI3NjkgMTAwNjQ0Ci0tLSBhL25ldC9pcHY2L3VkcF9vZmZsb2FkLmMKKysrIGIvbmV0L2lwdjYvdWRwX29mZmxvYWQuYwpAQCAtNTIsNiArNTIsMTAgQEAKIAogCQlza2Jfc2hpbmZvKHNrYiktPmdzb19zZWdzID0gRElWX1JPVU5EX1VQKHNrYi0+bGVuLCBtc3MpOwogCisJCS8qIFNldCB0aGUgSVB2NiBmcmFnbWVudCBpZCBpZiBub3Qgc2V0IHlldCAqLworCQlpZiAoIXNrYl9zaGluZm8oc2tiKS0+aXA2X2ZyYWdfaWQpCisJCQlpcHY2X3Byb3h5X3NlbGVjdF9pZGVudChza2IpOworCiAJCXNlZ3MgPSBOVUxMOwogCQlnb3RvIG91dDsKIAl9CkBAIC0xMDgsNyArMTEyLDExIEBACiAJCWZwdHIgPSAoc3RydWN0IGZyYWdfaGRyICopKHNrYl9uZXR3b3JrX2hlYWRlcihza2IpICsgdW5mcmFnX2lwNmhsZW4pOwogCQlmcHRyLT5uZXh0aGRyID0gbmV4dGhkcjsKIAkJZnB0ci0+cmVzZXJ2ZWQgPSAwOwotCQlmcHRyLT5pZGVudGlmaWNhdGlvbiA9IHNrYl9zaGluZm8oc2tiKS0+aXA2X2ZyYWdfaWQ7CisJCWlmIChza2Jfc2hpbmZvKHNrYiktPmlwNl9mcmFnX2lkKQorCQkJZnB0ci0+aWRlbnRpZmljYXRpb24gPSBza2Jfc2hpbmZvKHNrYiktPmlwNl9mcmFnX2lkOworCQllbHNlCisJCQlpcHY2X3NlbGVjdF9pZGVudChmcHRyLAorCQkJCQkgIChzdHJ1Y3QgcnQ2X2luZm8gKilza2JfZHN0KHNrYikpOwogCiAJCS8qIEZyYWdtZW50IHRoZSBza2IuIGlwdjYgaGVhZGVyIGFuZCB0aGUgcmVtYWluaW5nIGZpZWxkcyBvZiB0aGUKIAkJICogZnJhZ21lbnQgaGVhZGVyIGFyZSB1cGRhdGVkIGluIGlwdjZfZ3NvX3NlZ21lbnQoKQpkaWZmIC0tZ2l0IGEvbmV0L2lwdjYveGZybTZfcG9saWN5LmMgYi9uZXQvaXB2Ni94ZnJtNl9wb2xpY3kuYwppbmRleCA1Zjk4MzY0Li40OGJmNWEwIDEwMDY0NAotLS0gYS9uZXQvaXB2Ni94ZnJtNl9wb2xpY3kuYworKysgYi9uZXQvaXB2Ni94ZnJtNl9wb2xpY3kuYwpAQCAtMTMwLDEyICsxMzAsMTggQEAKIHsKIAlzdHJ1Y3QgZmxvd2k2ICpmbDYgPSAmZmwtPnUuaXA2OwogCWludCBvbmx5cHJvdG8gPSAwOwotCXUxNiBvZmZzZXQgPSBza2JfbmV0d29ya19oZWFkZXJfbGVuKHNrYik7CiAJY29uc3Qgc3RydWN0IGlwdjZoZHIgKmhkciA9IGlwdjZfaGRyKHNrYik7CisJdTE2IG9mZnNldCA9IHNpemVvZigqaGRyKTsKIAlzdHJ1Y3QgaXB2Nl9vcHRfaGRyICpleHRoZHI7CiAJY29uc3QgdW5zaWduZWQgY2hhciAqbmggPSBza2JfbmV0d29ya19oZWFkZXIoc2tiKTsKLQl1OCBuZXh0aGRyID0gbmhbSVA2Q0Ioc2tiKS0+bmhvZmZdOworCXUxNiBuaG9mZiA9IElQNkNCKHNrYiktPm5ob2ZmOwogCWludCBvaWYgPSAwOworCXU4IG5leHRoZHI7CisKKwlpZiAoIW5ob2ZmKQorCQluaG9mZiA9IG9mZnNldG9mKHN0cnVjdCBpcHY2aGRyLCBuZXh0aGRyKTsKKworCW5leHRoZHIgPSBuaFtuaG9mZl07CiAKIAlpZiAoc2tiX2RzdChza2IpKQogCQlvaWYgPSBza2JfZHN0KHNrYiktPmRldi0+aWZpbmRleDsKZGlmZiAtLWdpdCBhL25ldC9sbGMvc3lzY3RsX25ldF9sbGMuYyBiL25ldC9sbGMvc3lzY3RsX25ldF9sbGMuYwppbmRleCA2MTJhNWRkLi43OTliYWZjIDEwMDY0NAotLS0gYS9uZXQvbGxjL3N5c2N0bF9uZXRfbGxjLmMKKysrIGIvbmV0L2xsYy9zeXNjdGxfbmV0X2xsYy5jCkBAIC0xOCwyOCArMTgsMjggQEAKIAl7CiAJCS5wcm9jbmFtZQk9ICJhY2siLAogCQkuZGF0YQkJPSAmc3lzY3RsX2xsYzJfYWNrX3RpbWVvdXQsCi0JCS5tYXhsZW4JCT0gc2l6ZW9mKGxvbmcpLAorCQkubWF4bGVuCQk9IHNpemVvZihzeXNjdGxfbGxjMl9hY2tfdGltZW91dCksCiAJCS5tb2RlCQk9IDA2NDQsCiAJCS5wcm9jX2hhbmRsZXIgICA9IHByb2NfZG9pbnR2ZWNfamlmZmllcywKIAl9LAogCXsKIAkJLnByb2NuYW1lCT0gImJ1c3kiLAogCQkuZGF0YQkJPSAmc3lzY3RsX2xsYzJfYnVzeV90aW1lb3V0LAotCQkubWF4bGVuCQk9IHNpemVvZihsb25nKSwKKwkJLm1heGxlbgkJPSBzaXplb2Yoc3lzY3RsX2xsYzJfYnVzeV90aW1lb3V0KSwKIAkJLm1vZGUJCT0gMDY0NCwKIAkJLnByb2NfaGFuZGxlciAgID0gcHJvY19kb2ludHZlY19qaWZmaWVzLAogCX0sCiAJewogCQkucHJvY25hbWUJPSAicCIsCiAJCS5kYXRhCQk9ICZzeXNjdGxfbGxjMl9wX3RpbWVvdXQsCi0JCS5tYXhsZW4JCT0gc2l6ZW9mKGxvbmcpLAorCQkubWF4bGVuCQk9IHNpemVvZihzeXNjdGxfbGxjMl9wX3RpbWVvdXQpLAogCQkubW9kZQkJPSAwNjQ0LAogCQkucHJvY19oYW5kbGVyICAgPSBwcm9jX2RvaW50dmVjX2ppZmZpZXMsCiAJfSwKIAl7CiAJCS5wcm9jbmFtZQk9ICJyZWoiLAogCQkuZGF0YQkJPSAmc3lzY3RsX2xsYzJfcmVqX3RpbWVvdXQsCi0JCS5tYXhsZW4JCT0gc2l6ZW9mKGxvbmcpLAorCQkubWF4bGVuCQk9IHNpemVvZihzeXNjdGxfbGxjMl9yZWpfdGltZW91dCksCiAJCS5tb2RlCQk9IDA2NDQsCiAJCS5wcm9jX2hhbmRsZXIgICA9IHByb2NfZG9pbnR2ZWNfamlmZmllcywKIAl9LApkaWZmIC0tZ2l0IGEvbmV0L21hYzgwMjExL21sbWUuYyBiL25ldC9tYWM4MDIxMS9tbG1lLmMKaW5kZXggMmMzNmM0Ny4uODM3YTQwNiAxMDA2NDQKLS0tIGEvbmV0L21hYzgwMjExL21sbWUuYworKysgYi9uZXQvbWFjODAyMTEvbWxtZS5jCkBAIC0xNjQzLDcgKzE2NDMsNyBAQAogewogCXN0cnVjdCBpZWVlODAyMTFfbG9jYWwgKmxvY2FsID0gc2RhdGEtPmxvY2FsOwogCXN0cnVjdCBpZWVlODAyMTFfaWZfbWFuYWdlZCAqaWZtZ2QgPSAmc2RhdGEtPnUubWdkOwotCWJvb2wgcmV0OworCWJvb2wgcmV0ID0gZmFsc2U7CiAJaW50IGFjOwogCiAJaWYgKGxvY2FsLT5ody5xdWV1ZXMgPCBJRUVFODAyMTFfTlVNX0FDUykKZGlmZiAtLWdpdCBhL25ldC9tYWM4MDIxMS9wbS5jIGIvbmV0L21hYzgwMjExL3BtLmMKaW5kZXggNGM1MTkyZS4uNGE5NWZlMyAxMDA2NDQKLS0tIGEvbmV0L21hYzgwMjExL3BtLmMKKysrIGIvbmV0L21hYzgwMjExL3BtLmMKQEAgLTg2LDIwICs4Niw2IEBACiAJCX0KIAl9CiAKLQkvKiB0ZWFyIGRvd24gYWdncmVnYXRpb24gc2Vzc2lvbnMgYW5kIHJlbW92ZSBTVEFzICovCi0JbXV0ZXhfbG9jaygmbG9jYWwtPnN0YV9tdHgpOwotCWxpc3RfZm9yX2VhY2hfZW50cnkoc3RhLCAmbG9jYWwtPnN0YV9saXN0LCBsaXN0KSB7Ci0JCWlmIChzdGEtPnVwbG9hZGVkKSB7Ci0JCQllbnVtIGllZWU4MDIxMV9zdGFfc3RhdGUgc3RhdGU7Ci0KLQkJCXN0YXRlID0gc3RhLT5zdGFfc3RhdGU7Ci0JCQlmb3IgKDsgc3RhdGUgPiBJRUVFODAyMTFfU1RBX05PVEVYSVNUOyBzdGF0ZS0tKQotCQkJCVdBUk5fT04oZHJ2X3N0YV9zdGF0ZShsb2NhbCwgc3RhLT5zZGF0YSwgc3RhLAotCQkJCQkJICAgICAgc3RhdGUsIHN0YXRlIC0gMSkpOwotCQl9Ci0JfQotCW11dGV4X3VubG9jaygmbG9jYWwtPnN0YV9tdHgpOwotCiAJLyogcmVtb3ZlIGFsbCBpbnRlcmZhY2VzIHRoYXQgd2VyZSBjcmVhdGVkIGluIHRoZSBkcml2ZXIgKi8KIAlsaXN0X2Zvcl9lYWNoX2VudHJ5KHNkYXRhLCAmbG9jYWwtPmludGVyZmFjZXMsIGxpc3QpIHsKIAkJaWYgKCFpZWVlODAyMTFfc2RhdGFfcnVubmluZyhzZGF0YSkpCkBAIC0xMTEsNiArOTcsMjEgQEAKIAkJY2FzZSBOTDgwMjExX0lGVFlQRV9TVEFUSU9OOgogCQkJaWVlZTgwMjExX21nZF9xdWllc2NlKHNkYXRhKTsKIAkJCWJyZWFrOworCQljYXNlIE5MODAyMTFfSUZUWVBFX1dEUzoKKwkJCS8qIHRlYXIgZG93biBhZ2dyZWdhdGlvbiBzZXNzaW9ucyBhbmQgcmVtb3ZlIFNUQXMgKi8KKwkJCW11dGV4X2xvY2soJmxvY2FsLT5zdGFfbXR4KTsKKwkJCXN0YSA9IHNkYXRhLT51Lndkcy5zdGE7CisJCQlpZiAoc3RhICYmIHN0YS0+dXBsb2FkZWQpIHsKKwkJCQllbnVtIGllZWU4MDIxMV9zdGFfc3RhdGUgc3RhdGU7CisKKwkJCQlzdGF0ZSA9IHN0YS0+c3RhX3N0YXRlOworCQkJCWZvciAoOyBzdGF0ZSA+IElFRUU4MDIxMV9TVEFfTk9URVhJU1Q7IHN0YXRlLS0pCisJCQkJCVdBUk5fT04oZHJ2X3N0YV9zdGF0ZShsb2NhbCwgc3RhLT5zZGF0YSwKKwkJCQkJCQkgICAgICBzdGEsIHN0YXRlLAorCQkJCQkJCSAgICAgIHN0YXRlIC0gMSkpOworCQkJfQorCQkJbXV0ZXhfdW5sb2NrKCZsb2NhbC0+c3RhX210eCk7CisJCQlicmVhazsKIAkJZGVmYXVsdDoKIAkJCWJyZWFrOwogCQl9CmRpZmYgLS1naXQgYS9uZXQvbWFjODAyMTEvcnguYyBiL25ldC9tYWM4MDIxMS9yeC5jCmluZGV4IDY4M2IxMGYuLmQ2OWNhNTEgMTAwNjQ0Ci0tLSBhL25ldC9tYWM4MDIxMS9yeC5jCisrKyBiL25ldC9tYWM4MDIxMS9yeC5jCkBAIC0yNzIsNyArMjcyLDcgQEAKIAllbHNlIGlmIChyYXRlICYmIHJhdGUtPmZsYWdzICYgSUVFRTgwMjExX1JBVEVfRVJQX0cpCiAJCWNoYW5uZWxfZmxhZ3MgfD0gSUVFRTgwMjExX0NIQU5fT0ZETSB8IElFRUU4MDIxMV9DSEFOXzJHSFo7CiAJZWxzZSBpZiAocmF0ZSkKLQkJY2hhbm5lbF9mbGFncyB8PSBJRUVFODAyMTFfQ0hBTl9PRkRNIHwgSUVFRTgwMjExX0NIQU5fMkdIWjsKKwkJY2hhbm5lbF9mbGFncyB8PSBJRUVFODAyMTFfQ0hBTl9DQ0sgfCBJRUVFODAyMTFfQ0hBTl8yR0haOwogCWVsc2UKIAkJY2hhbm5lbF9mbGFncyB8PSBJRUVFODAyMTFfQ0hBTl8yR0haOwogCXB1dF91bmFsaWduZWRfbGUxNihjaGFubmVsX2ZsYWdzLCBwb3MpOwpkaWZmIC0tZ2l0IGEvbmV0L25ldGZpbHRlci9pcHZzL2lwX3ZzX2NvcmUuYyBiL25ldC9uZXRmaWx0ZXIvaXB2cy9pcF92c19jb3JlLmMKaW5kZXggOTkwZGVjYi4uYjg3Y2EzMiAxMDA2NDQKLS0tIGEvbmV0L25ldGZpbHRlci9pcHZzL2lwX3ZzX2NvcmUuYworKysgYi9uZXQvbmV0ZmlsdGVyL2lwdnMvaXBfdnNfY29yZS5jCkBAIC02NTksMTYgKzY1OSwyNCBAQAogCXJldHVybiBlcnI7CiB9CiAKLXN0YXRpYyBpbnQgaXBfdnNfcm91dGVfbWVfaGFyZGVyKGludCBhZiwgc3RydWN0IHNrX2J1ZmYgKnNrYikKK3N0YXRpYyBpbnQgaXBfdnNfcm91dGVfbWVfaGFyZGVyKGludCBhZiwgc3RydWN0IHNrX2J1ZmYgKnNrYiwKKwkJCQkgdW5zaWduZWQgaW50IGhvb2tudW0pCiB7CisJaWYgKCFzeXNjdGxfc25hdF9yZXJvdXRlKHNrYikpCisJCXJldHVybiAwOworCS8qIFJlcm91dGUgcmVwbGllcyBvbmx5IHRvIHJlbW90ZSBjbGllbnRzIChGT1JXQVJEIGFuZCBMT0NBTF9PVVQpICovCisJaWYgKE5GX0lORVRfTE9DQUxfSU4gPT0gaG9va251bSkKKwkJcmV0dXJuIDA7CiAjaWZkZWYgQ09ORklHX0lQX1ZTX0lQVjYKIAlpZiAoYWYgPT0gQUZfSU5FVDYpIHsKLQkJaWYgKHN5c2N0bF9zbmF0X3Jlcm91dGUoc2tiKSAmJiBpcDZfcm91dGVfbWVfaGFyZGVyKHNrYikgIT0gMCkKKwkJc3RydWN0IGRzdF9lbnRyeSAqZHN0ID0gc2tiX2RzdChza2IpOworCisJCWlmIChkc3QtPmRldiAmJiAhKGRzdC0+ZGV2LT5mbGFncyAmIElGRl9MT09QQkFDSykgJiYKKwkJICAgIGlwNl9yb3V0ZV9tZV9oYXJkZXIoc2tiKSAhPSAwKQogCQkJcmV0dXJuIDE7CiAJfSBlbHNlCiAjZW5kaWYKLQkJaWYgKChzeXNjdGxfc25hdF9yZXJvdXRlKHNrYikgfHwKLQkJICAgICBza2JfcnRhYmxlKHNrYiktPnJ0X2ZsYWdzICYgUlRDRl9MT0NBTCkgJiYKKwkJaWYgKCEoc2tiX3J0YWJsZShza2IpLT5ydF9mbGFncyAmIFJUQ0ZfTE9DQUwpICYmCiAJCSAgICBpcF9yb3V0ZV9tZV9oYXJkZXIoc2tiLCBSVE5fTE9DQUwpICE9IDApCiAJCQlyZXR1cm4gMTsKIApAQCAtNzkxLDcgKzc5OSw4IEBACiAJCQkJdW5pb24gbmZfaW5ldF9hZGRyICpzbmV0LAogCQkJCV9fdTggcHJvdG9jb2wsIHN0cnVjdCBpcF92c19jb25uICpjcCwKIAkJCQlzdHJ1Y3QgaXBfdnNfcHJvdG9jb2wgKnBwLAotCQkJCXVuc2lnbmVkIGludCBvZmZzZXQsIHVuc2lnbmVkIGludCBpaGwpCisJCQkJdW5zaWduZWQgaW50IG9mZnNldCwgdW5zaWduZWQgaW50IGlobCwKKwkJCQl1bnNpZ25lZCBpbnQgaG9va251bSkKIHsKIAl1bnNpZ25lZCBpbnQgdmVyZGljdCA9IE5GX0RST1A7CiAKQEAgLTgyMSw3ICs4MzAsNyBAQAogI2VuZGlmCiAJCWlwX3ZzX25hdF9pY21wKHNrYiwgcHAsIGNwLCAxKTsKIAotCWlmIChpcF92c19yb3V0ZV9tZV9oYXJkZXIoYWYsIHNrYikpCisJaWYgKGlwX3ZzX3JvdXRlX21lX2hhcmRlcihhZiwgc2tiLCBob29rbnVtKSkKIAkJZ290byBvdXQ7CiAKIAkvKiBkbyB0aGUgc3RhdGlzdGljcyBhbmQgcHV0IGl0IGJhY2sgKi8KQEAgLTkxNiw3ICs5MjUsNyBAQAogCiAJc25ldC5pcCA9IGlwaC0+c2FkZHI7CiAJcmV0dXJuIGhhbmRsZV9yZXNwb25zZV9pY21wKEFGX0lORVQsIHNrYiwgJnNuZXQsIGNpaC0+cHJvdG9jb2wsIGNwLAotCQkJCSAgICBwcCwgY2lwaC5sZW4sIGlobCk7CisJCQkJICAgIHBwLCBjaXBoLmxlbiwgaWhsLCBob29rbnVtKTsKIH0KIAogI2lmZGVmIENPTkZJR19JUF9WU19JUFY2CkBAIC05ODEsNyArOTkwLDggQEAKIAlzbmV0LmluNiA9IGNpcGguc2FkZHIuaW42OwogCXdyaXRhYmxlID0gY2lwaC5sZW47CiAJcmV0dXJuIGhhbmRsZV9yZXNwb25zZV9pY21wKEFGX0lORVQ2LCBza2IsICZzbmV0LCBjaXBoLnByb3RvY29sLCBjcCwKLQkJCQkgICAgcHAsIHdyaXRhYmxlLCBzaXplb2Yoc3RydWN0IGlwdjZoZHIpKTsKKwkJCQkgICAgcHAsIHdyaXRhYmxlLCBzaXplb2Yoc3RydWN0IGlwdjZoZHIpLAorCQkJCSAgICBob29rbnVtKTsKIH0KICNlbmRpZgogCkBAIC0xMDQwLDcgKzEwNTAsOCBAQAogICovCiBzdGF0aWMgdW5zaWduZWQgaW50CiBoYW5kbGVfcmVzcG9uc2UoaW50IGFmLCBzdHJ1Y3Qgc2tfYnVmZiAqc2tiLCBzdHJ1Y3QgaXBfdnNfcHJvdG9fZGF0YSAqcGQsCi0JCXN0cnVjdCBpcF92c19jb25uICpjcCwgc3RydWN0IGlwX3ZzX2lwaGRyICppcGgpCisJCXN0cnVjdCBpcF92c19jb25uICpjcCwgc3RydWN0IGlwX3ZzX2lwaGRyICppcGgsCisJCXVuc2lnbmVkIGludCBob29rbnVtKQogewogCXN0cnVjdCBpcF92c19wcm90b2NvbCAqcHAgPSBwZC0+cHA7CiAKQEAgLTEwNzgsNyArMTA4OSw3IEBACiAJICogaWYgaXQgY2FtZSBmcm9tIHRoaXMgbWFjaGluZSBpdHNlbGYuICBTbyByZS1jb21wdXRlCiAJICogdGhlIHJvdXRpbmcgaW5mb3JtYXRpb24uCiAJICovCi0JaWYgKGlwX3ZzX3JvdXRlX21lX2hhcmRlcihhZiwgc2tiKSkKKwlpZiAoaXBfdnNfcm91dGVfbWVfaGFyZGVyKGFmLCBza2IsIGhvb2tudW0pKQogCQlnb3RvIGRyb3A7CiAKIAlJUF9WU19EQkdfUEtUKDEwLCBhZiwgcHAsIHNrYiwgMCwgIkFmdGVyIFNOQVQiKTsKQEAgLTExODEsNyArMTE5Miw3IEBACiAJY3AgPSBwcC0+Y29ubl9vdXRfZ2V0KGFmLCBza2IsICZpcGgsIDApOwogCiAJaWYgKGxpa2VseShjcCkpCi0JCXJldHVybiBoYW5kbGVfcmVzcG9uc2UoYWYsIHNrYiwgcGQsIGNwLCAmaXBoKTsKKwkJcmV0dXJuIGhhbmRsZV9yZXNwb25zZShhZiwgc2tiLCBwZCwgY3AsICZpcGgsIGhvb2tudW0pOwogCWlmIChzeXNjdGxfbmF0X2ljbXBfc2VuZChuZXQpICYmCiAJICAgIChwcC0+cHJvdG9jb2wgPT0gSVBQUk9UT19UQ1AgfHwKIAkgICAgIHBwLT5wcm90b2NvbCA9PSBJUFBST1RPX1VEUCB8fApkaWZmIC0tZ2l0IGEvbmV0L25ldGZpbHRlci9uZl90YWJsZXNfYXBpLmMgYi9uZXQvbmV0ZmlsdGVyL25mX3RhYmxlc19hcGkuYwppbmRleCAzYjNkZGI0Li4xZmYwNGJjIDEwMDY0NAotLS0gYS9uZXQvbmV0ZmlsdGVyL25mX3RhYmxlc19hcGkuYworKysgYi9uZXQvbmV0ZmlsdGVyL25mX3RhYmxlc19hcGkuYwpAQCAtMTEzNCw5ICsxMTM0LDExIEBACiAJLyogUmVzdG9yZSBvbGQgY291bnRlcnMgb24gdGhpcyBjcHUsIG5vIHByb2JsZW0uIFBlci1jcHUgc3RhdGlzdGljcwogCSAqIGFyZSBub3QgZXhwb3NlZCB0byB1c2Vyc3BhY2UuCiAJICovCisJcHJlZW1wdF9kaXNhYmxlKCk7CiAJc3RhdHMgPSB0aGlzX2NwdV9wdHIobmV3c3RhdHMpOwogCXN0YXRzLT5ieXRlcyA9IGJlNjRfdG9fY3B1KG5sYV9nZXRfYmU2NCh0YltORlRBX0NPVU5URVJfQllURVNdKSk7CiAJc3RhdHMtPnBrdHMgPSBiZTY0X3RvX2NwdShubGFfZ2V0X2JlNjQodGJbTkZUQV9DT1VOVEVSX1BBQ0tFVFNdKSk7CisJcHJlZW1wdF9lbmFibGUoKTsKIAogCXJldHVybiBuZXdzdGF0czsKIH0KQEAgLTEyNjIsOCArMTI2NCwxMCBAQAogCQluZnRfY3R4X2luaXQoJmN0eCwgc2tiLCBubGgsIGFmaSwgdGFibGUsIGNoYWluLCBubGEpOwogCQl0cmFucyA9IG5mdF90cmFuc19hbGxvYygmY3R4LCBORlRfTVNHX05FV0NIQUlOLAogCQkJCQlzaXplb2Yoc3RydWN0IG5mdF90cmFuc19jaGFpbikpOwotCQlpZiAodHJhbnMgPT0gTlVMTCkKKwkJaWYgKHRyYW5zID09IE5VTEwpIHsKKwkJCWZyZWVfcGVyY3B1KHN0YXRzKTsKIAkJCXJldHVybiAtRU5PTUVNOworCQl9CiAKIAkJbmZ0X3RyYW5zX2NoYWluX3N0YXRzKHRyYW5zKSA9IHN0YXRzOwogCQluZnRfdHJhbnNfY2hhaW5fdXBkYXRlKHRyYW5zKSA9IHRydWU7CkBAIC0xMzE5LDggKzEzMjMsMTAgQEAKIAkJaG9va2ZuID0gdHlwZS0+aG9va3NbaG9va251bV07CiAKIAkJYmFzZWNoYWluID0ga3phbGxvYyhzaXplb2YoKmJhc2VjaGFpbiksIEdGUF9LRVJORUwpOwotCQlpZiAoYmFzZWNoYWluID09IE5VTEwpCisJCWlmIChiYXNlY2hhaW4gPT0gTlVMTCkgeworCQkJbW9kdWxlX3B1dCh0eXBlLT5vd25lcik7CiAJCQlyZXR1cm4gLUVOT01FTTsKKwkJfQogCiAJCWlmIChubGFbTkZUQV9DSEFJTl9DT1VOVEVSU10pIHsKIAkJCXN0YXRzID0gbmZ0X3N0YXRzX2FsbG9jKG5sYVtORlRBX0NIQUlOX0NPVU5URVJTXSk7CkBAIC0zNzUzLDYgKzM3NTksMjQgQEAKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKG5mdF9jaGFpbl92YWxpZGF0ZV9kZXBlbmRlbmN5KTsKIAoraW50IG5mdF9jaGFpbl92YWxpZGF0ZV9ob29rcyhjb25zdCBzdHJ1Y3QgbmZ0X2NoYWluICpjaGFpbiwKKwkJCSAgICAgdW5zaWduZWQgaW50IGhvb2tfZmxhZ3MpCit7CisJc3RydWN0IG5mdF9iYXNlX2NoYWluICpiYXNlY2hhaW47CisKKwlpZiAoY2hhaW4tPmZsYWdzICYgTkZUX0JBU0VfQ0hBSU4pIHsKKwkJYmFzZWNoYWluID0gbmZ0X2Jhc2VfY2hhaW4oY2hhaW4pOworCisJCWlmICgoMSA8PCBiYXNlY2hhaW4tPm9wc1swXS5ob29rbnVtKSAmIGhvb2tfZmxhZ3MpCisJCQlyZXR1cm4gMDsKKworCQlyZXR1cm4gLUVPUE5PVFNVUFA7CisJfQorCisJcmV0dXJuIDA7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChuZnRfY2hhaW5fdmFsaWRhdGVfaG9va3MpOworCiAvKgogICogTG9vcCBkZXRlY3Rpb24gLSB3YWxrIHRocm91Z2ggdGhlIHJ1bGVzZXQgYmVnaW5uaW5nIGF0IHRoZSBkZXN0aW5hdGlvbiBjaGFpbgogICogb2YgYSBuZXcganVtcCB1bnRpbCBlaXRoZXIgdGhlIHNvdXJjZSBjaGFpbiBpcyByZWFjaGVkIChsb29wKSBvciBhbGwKZGlmZiAtLWdpdCBhL25ldC9uZXRmaWx0ZXIvbmZ0X21hc3EuYyBiL25ldC9uZXRmaWx0ZXIvbmZ0X21hc3EuYwppbmRleCBkMWZmZDVlLi45YWVhNzQ3IDEwMDY0NAotLS0gYS9uZXQvbmV0ZmlsdGVyL25mdF9tYXNxLmMKKysrIGIvbmV0L25ldGZpbHRlci9uZnRfbWFzcS5jCkBAIC0yMSw2ICsyMSwyMSBAQAogfTsKIEVYUE9SVF9TWU1CT0xfR1BMKG5mdF9tYXNxX3BvbGljeSk7CiAKK2ludCBuZnRfbWFzcV92YWxpZGF0ZShjb25zdCBzdHJ1Y3QgbmZ0X2N0eCAqY3R4LAorCQkgICAgICBjb25zdCBzdHJ1Y3QgbmZ0X2V4cHIgKmV4cHIsCisJCSAgICAgIGNvbnN0IHN0cnVjdCBuZnRfZGF0YSAqKmRhdGEpCit7CisJaW50IGVycjsKKworCWVyciA9IG5mdF9jaGFpbl92YWxpZGF0ZV9kZXBlbmRlbmN5KGN0eC0+Y2hhaW4sIE5GVF9DSEFJTl9UX05BVCk7CisJaWYgKGVyciA8IDApCisJCXJldHVybiBlcnI7CisKKwlyZXR1cm4gbmZ0X2NoYWluX3ZhbGlkYXRlX2hvb2tzKGN0eC0+Y2hhaW4sCisJCQkJICAgICAgICAoMSA8PCBORl9JTkVUX1BPU1RfUk9VVElORykpOworfQorRVhQT1JUX1NZTUJPTF9HUEwobmZ0X21hc3FfdmFsaWRhdGUpOworCiBpbnQgbmZ0X21hc3FfaW5pdChjb25zdCBzdHJ1Y3QgbmZ0X2N0eCAqY3R4LAogCQkgIGNvbnN0IHN0cnVjdCBuZnRfZXhwciAqZXhwciwKIAkJICBjb25zdCBzdHJ1Y3QgbmxhdHRyICogY29uc3QgdGJbXSkKQEAgLTI4LDggKzQzLDggQEAKIAlzdHJ1Y3QgbmZ0X21hc3EgKnByaXYgPSBuZnRfZXhwcl9wcml2KGV4cHIpOwogCWludCBlcnI7CiAKLQllcnIgPSBuZnRfY2hhaW5fdmFsaWRhdGVfZGVwZW5kZW5jeShjdHgtPmNoYWluLCBORlRfQ0hBSU5fVF9OQVQpOwotCWlmIChlcnIgPCAwKQorCWVyciA9IG5mdF9tYXNxX3ZhbGlkYXRlKGN0eCwgZXhwciwgTlVMTCk7CisJaWYgKGVycikKIAkJcmV0dXJuIGVycjsKIAogCWlmICh0YltORlRBX01BU1FfRkxBR1NdID09IE5VTEwpCkBAIC02MCwxMiArNzUsNSBAQAogfQogRVhQT1JUX1NZTUJPTF9HUEwobmZ0X21hc3FfZHVtcCk7CiAKLWludCBuZnRfbWFzcV92YWxpZGF0ZShjb25zdCBzdHJ1Y3QgbmZ0X2N0eCAqY3R4LCBjb25zdCBzdHJ1Y3QgbmZ0X2V4cHIgKmV4cHIsCi0JCSAgICAgIGNvbnN0IHN0cnVjdCBuZnRfZGF0YSAqKmRhdGEpCi17Ci0JcmV0dXJuIG5mdF9jaGFpbl92YWxpZGF0ZV9kZXBlbmRlbmN5KGN0eC0+Y2hhaW4sIE5GVF9DSEFJTl9UX05BVCk7Ci19Ci1FWFBPUlRfU1lNQk9MX0dQTChuZnRfbWFzcV92YWxpZGF0ZSk7Ci0KIE1PRFVMRV9MSUNFTlNFKCJHUEwiKTsKIE1PRFVMRV9BVVRIT1IoIkFydHVybyBCb3JyZXJvIEdvbnphbGV6IDxhcnR1cm8uYm9ycmVyby5nbGV6QGdtYWlsLmNvbT4iKTsKZGlmZiAtLWdpdCBhL25ldC9uZXRmaWx0ZXIvbmZ0X25hdC5jIGIvbmV0L25ldGZpbHRlci9uZnRfbmF0LmMKaW5kZXggYWZmNTRmYjEuLmEwODM3YzYgMTAwNjQ0Ci0tLSBhL25ldC9uZXRmaWx0ZXIvbmZ0X25hdC5jCisrKyBiL25ldC9uZXRmaWx0ZXIvbmZ0X25hdC5jCkBAIC04OCw2ICs4OCwzMyBAQAogCVtORlRBX05BVF9GTEFHU10JID0geyAudHlwZSA9IE5MQV9VMzIgfSwKIH07CiAKK3N0YXRpYyBpbnQgbmZ0X25hdF92YWxpZGF0ZShjb25zdCBzdHJ1Y3QgbmZ0X2N0eCAqY3R4LAorCQkJICAgIGNvbnN0IHN0cnVjdCBuZnRfZXhwciAqZXhwciwKKwkJCSAgICBjb25zdCBzdHJ1Y3QgbmZ0X2RhdGEgKipkYXRhKQoreworCXN0cnVjdCBuZnRfbmF0ICpwcml2ID0gbmZ0X2V4cHJfcHJpdihleHByKTsKKwlpbnQgZXJyOworCisJZXJyID0gbmZ0X2NoYWluX3ZhbGlkYXRlX2RlcGVuZGVuY3koY3R4LT5jaGFpbiwgTkZUX0NIQUlOX1RfTkFUKTsKKwlpZiAoZXJyIDwgMCkKKwkJcmV0dXJuIGVycjsKKworCXN3aXRjaCAocHJpdi0+dHlwZSkgeworCWNhc2UgTkZUX05BVF9TTkFUOgorCQllcnIgPSBuZnRfY2hhaW5fdmFsaWRhdGVfaG9va3MoY3R4LT5jaGFpbiwKKwkJCQkJICAgICAgICgxIDw8IE5GX0lORVRfUE9TVF9ST1VUSU5HKSB8CisJCQkJCSAgICAgICAoMSA8PCBORl9JTkVUX0xPQ0FMX0lOKSk7CisJCWJyZWFrOworCWNhc2UgTkZUX05BVF9ETkFUOgorCQllcnIgPSBuZnRfY2hhaW5fdmFsaWRhdGVfaG9va3MoY3R4LT5jaGFpbiwKKwkJCQkJICAgICAgICgxIDw8IE5GX0lORVRfUFJFX1JPVVRJTkcpIHwKKwkJCQkJICAgICAgICgxIDw8IE5GX0lORVRfTE9DQUxfT1VUKSk7CisJCWJyZWFrOworCX0KKworCXJldHVybiBlcnI7Cit9CisKIHN0YXRpYyBpbnQgbmZ0X25hdF9pbml0KGNvbnN0IHN0cnVjdCBuZnRfY3R4ICpjdHgsIGNvbnN0IHN0cnVjdCBuZnRfZXhwciAqZXhwciwKIAkJCWNvbnN0IHN0cnVjdCBubGF0dHIgKiBjb25zdCB0YltdKQogewpAQCAtOTUsMTAgKzEyMiw2IEBACiAJdTMyIGZhbWlseTsKIAlpbnQgZXJyOwogCi0JZXJyID0gbmZ0X2NoYWluX3ZhbGlkYXRlX2RlcGVuZGVuY3koY3R4LT5jaGFpbiwgTkZUX0NIQUlOX1RfTkFUKTsKLQlpZiAoZXJyIDwgMCkKLQkJcmV0dXJuIGVycjsKLQogCWlmICh0YltORlRBX05BVF9UWVBFXSA9PSBOVUxMIHx8CiAJICAgICh0YltORlRBX05BVF9SRUdfQUREUl9NSU5dID09IE5VTEwgJiYKIAkgICAgIHRiW05GVEFfTkFUX1JFR19QUk9UT19NSU5dID09IE5VTEwpKQpAQCAtMTE1LDYgKzEzOCwxMCBAQAogCQlyZXR1cm4gLUVJTlZBTDsKIAl9CiAKKwllcnIgPSBuZnRfbmF0X3ZhbGlkYXRlKGN0eCwgZXhwciwgTlVMTCk7CisJaWYgKGVyciA8IDApCisJCXJldHVybiBlcnI7CisKIAlpZiAodGJbTkZUQV9OQVRfRkFNSUxZXSA9PSBOVUxMKQogCQlyZXR1cm4gLUVJTlZBTDsKIApAQCAtMjE5LDEzICsyNDYsNiBAQAogCXJldHVybiAtMTsKIH0KIAotc3RhdGljIGludCBuZnRfbmF0X3ZhbGlkYXRlKGNvbnN0IHN0cnVjdCBuZnRfY3R4ICpjdHgsCi0JCQkgICAgY29uc3Qgc3RydWN0IG5mdF9leHByICpleHByLAotCQkJICAgIGNvbnN0IHN0cnVjdCBuZnRfZGF0YSAqKmRhdGEpCi17Ci0JcmV0dXJuIG5mdF9jaGFpbl92YWxpZGF0ZV9kZXBlbmRlbmN5KGN0eC0+Y2hhaW4sIE5GVF9DSEFJTl9UX05BVCk7Ci19Ci0KIHN0YXRpYyBzdHJ1Y3QgbmZ0X2V4cHJfdHlwZSBuZnRfbmF0X3R5cGU7CiBzdGF0aWMgY29uc3Qgc3RydWN0IG5mdF9leHByX29wcyBuZnRfbmF0X29wcyA9IHsKIAkudHlwZSAgICAgICAgICAgPSAmbmZ0X25hdF90eXBlLApkaWZmIC0tZ2l0IGEvbmV0L25ldGZpbHRlci9uZnRfcmVkaXIuYyBiL25ldC9uZXRmaWx0ZXIvbmZ0X3JlZGlyLmMKaW5kZXggOWU4MDkzZi4uZDdlOWU5MyAxMDA2NDQKLS0tIGEvbmV0L25ldGZpbHRlci9uZnRfcmVkaXIuYworKysgYi9uZXQvbmV0ZmlsdGVyL25mdF9yZWRpci5jCkBAIC0yMyw2ICsyMywyMiBAQAogfTsKIEVYUE9SVF9TWU1CT0xfR1BMKG5mdF9yZWRpcl9wb2xpY3kpOwogCitpbnQgbmZ0X3JlZGlyX3ZhbGlkYXRlKGNvbnN0IHN0cnVjdCBuZnRfY3R4ICpjdHgsCisJCSAgICAgICBjb25zdCBzdHJ1Y3QgbmZ0X2V4cHIgKmV4cHIsCisJCSAgICAgICBjb25zdCBzdHJ1Y3QgbmZ0X2RhdGEgKipkYXRhKQoreworCWludCBlcnI7CisKKwllcnIgPSBuZnRfY2hhaW5fdmFsaWRhdGVfZGVwZW5kZW5jeShjdHgtPmNoYWluLCBORlRfQ0hBSU5fVF9OQVQpOworCWlmIChlcnIgPCAwKQorCQlyZXR1cm4gZXJyOworCisJcmV0dXJuIG5mdF9jaGFpbl92YWxpZGF0ZV9ob29rcyhjdHgtPmNoYWluLAorCQkJCQkoMSA8PCBORl9JTkVUX1BSRV9ST1VUSU5HKSB8CisJCQkJCSgxIDw8IE5GX0lORVRfTE9DQUxfT1VUKSk7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChuZnRfcmVkaXJfdmFsaWRhdGUpOworCiBpbnQgbmZ0X3JlZGlyX2luaXQoY29uc3Qgc3RydWN0IG5mdF9jdHggKmN0eCwKIAkJICAgY29uc3Qgc3RydWN0IG5mdF9leHByICpleHByLAogCQkgICBjb25zdCBzdHJ1Y3QgbmxhdHRyICogY29uc3QgdGJbXSkKQEAgLTMwLDcgKzQ2LDcgQEAKIAlzdHJ1Y3QgbmZ0X3JlZGlyICpwcml2ID0gbmZ0X2V4cHJfcHJpdihleHByKTsKIAlpbnQgZXJyOwogCi0JZXJyID0gbmZ0X2NoYWluX3ZhbGlkYXRlX2RlcGVuZGVuY3koY3R4LT5jaGFpbiwgTkZUX0NIQUlOX1RfTkFUKTsKKwllcnIgPSBuZnRfcmVkaXJfdmFsaWRhdGUoY3R4LCBleHByLCBOVUxMKTsKIAlpZiAoZXJyIDwgMCkKIAkJcmV0dXJuIGVycjsKIApAQCAtODgsMTIgKzEwNCw1IEBACiB9CiBFWFBPUlRfU1lNQk9MX0dQTChuZnRfcmVkaXJfZHVtcCk7CiAKLWludCBuZnRfcmVkaXJfdmFsaWRhdGUoY29uc3Qgc3RydWN0IG5mdF9jdHggKmN0eCwgY29uc3Qgc3RydWN0IG5mdF9leHByICpleHByLAotCQkgICAgICAgY29uc3Qgc3RydWN0IG5mdF9kYXRhICoqZGF0YSkKLXsKLQlyZXR1cm4gbmZ0X2NoYWluX3ZhbGlkYXRlX2RlcGVuZGVuY3koY3R4LT5jaGFpbiwgTkZUX0NIQUlOX1RfTkFUKTsKLX0KLUVYUE9SVF9TWU1CT0xfR1BMKG5mdF9yZWRpcl92YWxpZGF0ZSk7Ci0KIE1PRFVMRV9MSUNFTlNFKCJHUEwiKTsKIE1PRFVMRV9BVVRIT1IoIkFydHVybyBCb3JyZXJvIEdvbnphbGV6IDxhcnR1cm8uYm9ycmVyby5nbGV6QGdtYWlsLmNvbT4iKTsKZGlmZiAtLWdpdCBhL25ldC9uZXRsaW5rL2FmX25ldGxpbmsuYyBiL25ldC9uZXRsaW5rL2FmX25ldGxpbmsuYwppbmRleCA4NGVhNzZjLi43NTUzMmVmIDEwMDY0NAotLS0gYS9uZXQvbmV0bGluay9hZl9uZXRsaW5rLmMKKysrIGIvbmV0L25ldGxpbmsvYWZfbmV0bGluay5jCkBAIC02MSw2ICs2MSw3IEBACiAjaW5jbHVkZSA8bGludXgvcmhhc2h0YWJsZS5oPgogI2luY2x1ZGUgPGFzbS9jYWNoZWZsdXNoLmg+CiAjaW5jbHVkZSA8bGludXgvaGFzaC5oPgorI2luY2x1ZGUgPGxpbnV4L2dlbmV0bGluay5oPgogCiAjaW5jbHVkZSA8bmV0L25ldF9uYW1lc3BhY2UuaD4KICNpbmNsdWRlIDxuZXQvc29jay5oPgpAQCAtMTA5NSw2ICsxMDk2LDggQEAKIAkJX19za19kZWxfYmluZF9ub2RlKHNrKTsKIAkJbmV0bGlua191cGRhdGVfbGlzdGVuZXJzKHNrKTsKIAl9CisJaWYgKHNrLT5za19wcm90b2NvbCA9PSBORVRMSU5LX0dFTkVSSUMpCisJCWF0b21pY19pbmMoJmdlbmxfc2tfZGVzdHJ1Y3RpbmdfY250KTsKIAluZXRsaW5rX3RhYmxlX3VuZ3JhYigpOwogfQogCkBAIC0xMjExLDYgKzEyMTQsMjAgQEAKIAkgKiB3aWxsIGJlIHB1cmdlZC4KIAkgKi8KIAorCS8qIG11c3Qgbm90IGFjcXVpcmUgbmV0bGlua190YWJsZV9sb2NrIGluIGFueSB3YXkgYWdhaW4gYmVmb3JlIHVuYmluZAorCSAqIGFuZCBub3RpZnlpbmcgZ2VuZXRsaW5rIGlzIGRvbmUgYXMgb3RoZXJ3aXNlIGl0IG1pZ2h0IGRlYWRsb2NrCisJICovCisJaWYgKG5say0+bmV0bGlua191bmJpbmQpIHsKKwkJaW50IGk7CisKKwkJZm9yIChpID0gMDsgaSA8IG5say0+bmdyb3VwczsgaSsrKQorCQkJaWYgKHRlc3RfYml0KGksIG5say0+Z3JvdXBzKSkKKwkJCQlubGstPm5ldGxpbmtfdW5iaW5kKHNvY2tfbmV0KHNrKSwgaSArIDEpOworCX0KKwlpZiAoc2stPnNrX3Byb3RvY29sID09IE5FVExJTktfR0VORVJJQyAmJgorCSAgICBhdG9taWNfZGVjX3JldHVybigmZ2VubF9za19kZXN0cnVjdGluZ19jbnQpID09IDApCisJCXdha2VfdXAoJmdlbmxfc2tfZGVzdHJ1Y3Rpbmdfd2FpdHEpOworCiAJc29jay0+c2sgPSBOVUxMOwogCXdha2VfdXBfaW50ZXJydXB0aWJsZV9hbGwoJm5say0+d2FpdCk7CiAKQEAgLTEyNDYsMTMgKzEyNjMsNiBAQAogCQluZXRsaW5rX3RhYmxlX3VuZ3JhYigpOwogCX0KIAotCWlmIChubGstPm5ldGxpbmtfdW5iaW5kKSB7Ci0JCWludCBpOwotCi0JCWZvciAoaSA9IDA7IGkgPCBubGstPm5ncm91cHM7IGkrKykKLQkJCWlmICh0ZXN0X2JpdChpLCBubGstPmdyb3VwcykpCi0JCQkJbmxrLT5uZXRsaW5rX3VuYmluZChzb2NrX25ldChzayksIGkgKyAxKTsKLQl9CiAJa2ZyZWUobmxrLT5ncm91cHMpOwogCW5say0+Z3JvdXBzID0gTlVMTDsKIApAQCAtMTQyOCw3ICsxNDM4LDcgQEAKIAogCWZvciAodW5kbyA9IDA7IHVuZG8gPCBncm91cDsgdW5kbysrKQogCQlpZiAodGVzdF9iaXQodW5kbywgJmdyb3VwcykpCi0JCQlubGstPm5ldGxpbmtfdW5iaW5kKHNvY2tfbmV0KHNrKSwgdW5kbyk7CisJCQlubGstPm5ldGxpbmtfdW5iaW5kKHNvY2tfbmV0KHNrKSwgdW5kbyArIDEpOwogfQogCiBzdGF0aWMgaW50IG5ldGxpbmtfYmluZChzdHJ1Y3Qgc29ja2V0ICpzb2NrLCBzdHJ1Y3Qgc29ja2FkZHIgKmFkZHIsCkBAIC0xNDY2LDcgKzE0NzYsNyBAQAogCQlmb3IgKGdyb3VwID0gMDsgZ3JvdXAgPCBubGstPm5ncm91cHM7IGdyb3VwKyspIHsKIAkJCWlmICghdGVzdF9iaXQoZ3JvdXAsICZncm91cHMpKQogCQkJCWNvbnRpbnVlOwotCQkJZXJyID0gbmxrLT5uZXRsaW5rX2JpbmQobmV0LCBncm91cCk7CisJCQllcnIgPSBubGstPm5ldGxpbmtfYmluZChuZXQsIGdyb3VwICsgMSk7CiAJCQlpZiAoIWVycikKIAkJCQljb250aW51ZTsKIAkJCW5ldGxpbmtfdW5kb19iaW5kKGdyb3VwLCBncm91cHMsIHNrKTsKZGlmZiAtLWdpdCBhL25ldC9uZXRsaW5rL2FmX25ldGxpbmsuaCBiL25ldC9uZXRsaW5rL2FmX25ldGxpbmsuaAppbmRleCBmMTIzYTg4Li5mMWMzMWIzIDEwMDY0NAotLS0gYS9uZXQvbmV0bGluay9hZl9uZXRsaW5rLmgKKysrIGIvbmV0L25ldGxpbmsvYWZfbmV0bGluay5oCkBAIC0yLDYgKzIsNyBAQAogI2RlZmluZSBfQUZfTkVUTElOS19ICiAKICNpbmNsdWRlIDxsaW51eC9yaGFzaHRhYmxlLmg+CisjaW5jbHVkZSA8bGludXgvYXRvbWljLmg+CiAjaW5jbHVkZSA8bmV0L3NvY2suaD4KIAogI2RlZmluZSBOTEdSUFNaKHgpCShBTElHTih4LCBzaXplb2YodW5zaWduZWQgbG9uZykgKiA4KSAvIDgpCmRpZmYgLS1naXQgYS9uZXQvbmV0bGluay9nZW5ldGxpbmsuYyBiL25ldC9uZXRsaW5rL2dlbmV0bGluay5jCmluZGV4IDJlMTEwNjFlLi5lZTU3NDU5IDEwMDY0NAotLS0gYS9uZXQvbmV0bGluay9nZW5ldGxpbmsuYworKysgYi9uZXQvbmV0bGluay9nZW5ldGxpbmsuYwpAQCAtMjMsNiArMjMsOSBAQAogc3RhdGljIERFRklORV9NVVRFWChnZW5sX211dGV4KTsgLyogc2VyaWFsaXphdGlvbiBvZiBtZXNzYWdlIHByb2Nlc3NpbmcgKi8KIHN0YXRpYyBERUNMQVJFX1JXU0VNKGNiX2xvY2spOwogCithdG9taWNfdCBnZW5sX3NrX2Rlc3RydWN0aW5nX2NudCA9IEFUT01JQ19JTklUKDApOworREVDTEFSRV9XQUlUX1FVRVVFX0hFQUQoZ2VubF9za19kZXN0cnVjdGluZ193YWl0cSk7CisKIHZvaWQgZ2VubF9sb2NrKHZvaWQpCiB7CiAJbXV0ZXhfbG9jaygmZ2VubF9tdXRleCk7CkBAIC00MzUsMTUgKzQzOCwxOCBAQAogCiAJZ2VubF9sb2NrX2FsbCgpOwogCi0JZ2VubF91bnJlZ2lzdGVyX21jX2dyb3VwcyhmYW1pbHkpOwotCiAJbGlzdF9mb3JfZWFjaF9lbnRyeShyYywgZ2VubF9mYW1pbHlfY2hhaW4oZmFtaWx5LT5pZCksIGZhbWlseV9saXN0KSB7CiAJCWlmIChmYW1pbHktPmlkICE9IHJjLT5pZCB8fCBzdHJjbXAocmMtPm5hbWUsIGZhbWlseS0+bmFtZSkpCiAJCQljb250aW51ZTsKIAorCQlnZW5sX3VucmVnaXN0ZXJfbWNfZ3JvdXBzKGZhbWlseSk7CisKIAkJbGlzdF9kZWwoJnJjLT5mYW1pbHlfbGlzdCk7CiAJCWZhbWlseS0+bl9vcHMgPSAwOwotCQlnZW5sX3VubG9ja19hbGwoKTsKKwkJdXBfd3JpdGUoJmNiX2xvY2spOworCQl3YWl0X2V2ZW50KGdlbmxfc2tfZGVzdHJ1Y3Rpbmdfd2FpdHEsCisJCQkgICBhdG9taWNfcmVhZCgmZ2VubF9za19kZXN0cnVjdGluZ19jbnQpID09IDApOworCQlnZW5sX3VubG9jaygpOwogCiAJCWtmcmVlKGZhbWlseS0+YXR0cmJ1Zik7CiAJCWdlbmxfY3RybF9ldmVudChDVFJMX0NNRF9ERUxGQU1JTFksIGZhbWlseSwgTlVMTCwgMCk7CkBAIC05ODUsNyArOTkxLDcgQEAKIAogc3RhdGljIGludCBnZW5sX2JpbmQoc3RydWN0IG5ldCAqbmV0LCBpbnQgZ3JvdXApCiB7Ci0JaW50IGksIGVyciA9IDA7CisJaW50IGksIGVyciA9IC1FTk9FTlQ7CiAKIAlkb3duX3JlYWQoJmNiX2xvY2spOwogCWZvciAoaSA9IDA7IGkgPCBHRU5MX0ZBTV9UQUJfU0laRTsgaSsrKSB7CkBAIC0xMDE0LDcgKzEwMjAsNiBAQAogc3RhdGljIHZvaWQgZ2VubF91bmJpbmQoc3RydWN0IG5ldCAqbmV0LCBpbnQgZ3JvdXApCiB7CiAJaW50IGk7Ci0JYm9vbCBmb3VuZCA9IGZhbHNlOwogCiAJZG93bl9yZWFkKCZjYl9sb2NrKTsKIAlmb3IgKGkgPSAwOyBpIDwgR0VOTF9GQU1fVEFCX1NJWkU7IGkrKykgewpAQCAtMTAyNywxNCArMTAzMiwxMSBAQAogCiAJCQkJaWYgKGYtPm1jYXN0X3VuYmluZCkKIAkJCQkJZi0+bWNhc3RfdW5iaW5kKG5ldCwgZmFtX2dycCk7Ci0JCQkJZm91bmQgPSB0cnVlOwogCQkJCWJyZWFrOwogCQkJfQogCQl9CiAJfQogCXVwX3JlYWQoJmNiX2xvY2spOwotCi0JV0FSTl9PTighZm91bmQpOwogfQogCiBzdGF0aWMgaW50IF9fbmV0X2luaXQgZ2VubF9wZXJuZXRfaW5pdChzdHJ1Y3QgbmV0ICpuZXQpCmRpZmYgLS1naXQgYS9uZXQvcmRzL3N5c2N0bC5jIGIvbmV0L3Jkcy9zeXNjdGwuYwppbmRleCBjM2IwY2Q0My4uYzE3M2Y2OSAxMDA2NDQKLS0tIGEvbmV0L3Jkcy9zeXNjdGwuYworKysgYi9uZXQvcmRzL3N5c2N0bC5jCkBAIC03MSwxNCArNzEsMTQgQEAKIAl7CiAJCS5wcm9jbmFtZQk9ICJtYXhfdW5hY2tlZF9wYWNrZXRzIiwKIAkJLmRhdGEJCT0gJnJkc19zeXNjdGxfbWF4X3VuYWNrZWRfcGFja2V0cywKLQkJLm1heGxlbiAgICAgICAgID0gc2l6ZW9mKHVuc2lnbmVkIGxvbmcpLAorCQkubWF4bGVuICAgICAgICAgPSBzaXplb2YoaW50KSwKIAkJLm1vZGUgICAgICAgICAgID0gMDY0NCwKIAkJLnByb2NfaGFuZGxlciAgID0gcHJvY19kb2ludHZlYywKIAl9LAogCXsKIAkJLnByb2NuYW1lCT0gIm1heF91bmFja2VkX2J5dGVzIiwKIAkJLmRhdGEJCT0gJnJkc19zeXNjdGxfbWF4X3VuYWNrZWRfYnl0ZXMsCi0JCS5tYXhsZW4gICAgICAgICA9IHNpemVvZih1bnNpZ25lZCBsb25nKSwKKwkJLm1heGxlbiAgICAgICAgID0gc2l6ZW9mKGludCksCiAJCS5tb2RlICAgICAgICAgICA9IDA2NDQsCiAJCS5wcm9jX2hhbmRsZXIgICA9IHByb2NfZG9pbnR2ZWMsCiAJfSwKZGlmZiAtLWdpdCBhL25ldC9zY2hlZC9jbHNfYXBpLmMgYi9uZXQvc2NoZWQvY2xzX2FwaS5jCmluZGV4IGFhZDZhNjcuLmJhZWY5ODcgMTAwNjQ0Ci0tLSBhL25ldC9zY2hlZC9jbHNfYXBpLmMKKysrIGIvbmV0L3NjaGVkL2Nsc19hcGkuYwpAQCAtNTU2LDggKzU1Niw5IEBACiB9CiBFWFBPUlRfU1lNQk9MKHRjZl9leHRzX2NoYW5nZSk7CiAKLSNkZWZpbmUgdGNmX2V4dHNfZmlyc3RfYWN0KGV4dCkgXAotCQlsaXN0X2ZpcnN0X2VudHJ5KCYoZXh0cyktPmFjdGlvbnMsIHN0cnVjdCB0Y19hY3Rpb24sIGxpc3QpCisjZGVmaW5lIHRjZl9leHRzX2ZpcnN0X2FjdChleHQpCQkJCQlcCisJbGlzdF9maXJzdF9lbnRyeV9vcl9udWxsKCYoZXh0cyktPmFjdGlvbnMsCQlcCisJCQkJIHN0cnVjdCB0Y19hY3Rpb24sIGxpc3QpCiAKIGludCB0Y2ZfZXh0c19kdW1wKHN0cnVjdCBza19idWZmICpza2IsIHN0cnVjdCB0Y2ZfZXh0cyAqZXh0cykKIHsKQEAgLTYwMyw3ICs2MDQsNyBAQAogewogI2lmZGVmIENPTkZJR19ORVRfQ0xTX0FDVAogCXN0cnVjdCB0Y19hY3Rpb24gKmEgPSB0Y2ZfZXh0c19maXJzdF9hY3QoZXh0cyk7Ci0JaWYgKHRjZl9hY3Rpb25fY29weV9zdGF0cyhza2IsIGEsIDEpIDwgMCkKKwlpZiAoYSAhPSBOVUxMICYmIHRjZl9hY3Rpb25fY29weV9zdGF0cyhza2IsIGEsIDEpIDwgMCkKIAkJcmV0dXJuIC0xOwogI2VuZGlmCiAJcmV0dXJuIDA7CmRpZmYgLS1naXQgYS9uZXQvc2NoZWQvY2xzX2JwZi5jIGIvbmV0L3NjaGVkL2Nsc19icGYuYwppbmRleCA4NGM4MjE5Li5mNTlhZGY4IDEwMDY0NAotLS0gYS9uZXQvc2NoZWQvY2xzX2JwZi5jCisrKyBiL25ldC9zY2hlZC9jbHNfYnBmLmMKQEAgLTE4MCw2ICsxODAsMTEgQEAKIAl9CiAKIAlicGZfc2l6ZSA9IGJwZl9sZW4gKiBzaXplb2YoKmJwZl9vcHMpOworCWlmIChicGZfc2l6ZSAhPSBubGFfbGVuKHRiW1RDQV9CUEZfT1BTXSkpIHsKKwkJcmV0ID0gLUVJTlZBTDsKKwkJZ290byBlcnJvdXQ7CisJfQorCiAJYnBmX29wcyA9IGt6YWxsb2MoYnBmX3NpemUsIEdGUF9LRVJORUwpOwogCWlmIChicGZfb3BzID09IE5VTEwpIHsKIAkJcmV0ID0gLUVOT01FTTsKQEAgLTIxNSwxNSArMjIwLDIxIEBACiAJCQkJICAgc3RydWN0IGNsc19icGZfaGVhZCAqaGVhZCkKIHsKIAl1bnNpZ25lZCBpbnQgaSA9IDB4ODAwMDAwMDA7CisJdTMyIGhhbmRsZTsKIAogCWRvIHsKIAkJaWYgKCsraGVhZC0+aGdlbiA9PSAweDdGRkZGRkZGKQogCQkJaGVhZC0+aGdlbiA9IDE7CiAJfSB3aGlsZSAoLS1pID4gMCAmJiBjbHNfYnBmX2dldCh0cCwgaGVhZC0+aGdlbikpOwotCWlmIChpID09IDApCi0JCXByX2VycigiSW5zdWZmaWNpZW50IG51bWJlciBvZiBoYW5kbGVzXG4iKTsKIAotCXJldHVybiBpOworCWlmICh1bmxpa2VseShpID09IDApKSB7CisJCXByX2VycigiSW5zdWZmaWNpZW50IG51bWJlciBvZiBoYW5kbGVzXG4iKTsKKwkJaGFuZGxlID0gMDsKKwl9IGVsc2UgeworCQloYW5kbGUgPSBoZWFkLT5oZ2VuOworCX0KKworCXJldHVybiBoYW5kbGU7CiB9CiAKIHN0YXRpYyBpbnQgY2xzX2JwZl9jaGFuZ2Uoc3RydWN0IG5ldCAqbmV0LCBzdHJ1Y3Qgc2tfYnVmZiAqaW5fc2tiLApkaWZmIC0tZ2l0IGEvbmV0L3NjaGVkL3NjaF9mcS5jIGIvbmV0L3NjaGVkL3NjaF9mcS5jCmluZGV4IDliMDU5MjQuLjMzM2NkOTQgMTAwNjQ0Ci0tLSBhL25ldC9zY2hlZC9zY2hfZnEuYworKysgYi9uZXQvc2NoZWQvc2NoX2ZxLmMKQEAgLTY3MCw4ICs2NzAsMTQgQEAKIAlpZiAodGJbVENBX0ZRX0ZMT1dfUExJTUlUXSkKIAkJcS0+Zmxvd19wbGltaXQgPSBubGFfZ2V0X3UzMih0YltUQ0FfRlFfRkxPV19QTElNSVRdKTsKIAotCWlmICh0YltUQ0FfRlFfUVVBTlRVTV0pCi0JCXEtPnF1YW50dW0gPSBubGFfZ2V0X3UzMih0YltUQ0FfRlFfUVVBTlRVTV0pOworCWlmICh0YltUQ0FfRlFfUVVBTlRVTV0pIHsKKwkJdTMyIHF1YW50dW0gPSBubGFfZ2V0X3UzMih0YltUQ0FfRlFfUVVBTlRVTV0pOworCisJCWlmIChxdWFudHVtID4gMCkKKwkJCXEtPnF1YW50dW0gPSBxdWFudHVtOworCQllbHNlCisJCQllcnIgPSAtRUlOVkFMOworCX0KIAogCWlmICh0YltUQ0FfRlFfSU5JVElBTF9RVUFOVFVNXSkKIAkJcS0+aW5pdGlhbF9xdWFudHVtID0gbmxhX2dldF91MzIodGJbVENBX0ZRX0lOSVRJQUxfUVVBTlRVTV0pOwpkaWZmIC0tZ2l0IGEvbmV0L3NjdHAvYXNzb2Npb2xhLmMgYi9uZXQvc2N0cC9hc3NvY2lvbGEuYwppbmRleCBmNzkxZWRkLi4yNmQwNmRiIDEwMDY0NAotLS0gYS9uZXQvc2N0cC9hc3NvY2lvbGEuYworKysgYi9uZXQvc2N0cC9hc3NvY2lvbGEuYwpAQCAtMTE4Miw3ICsxMTgyLDYgQEAKIAlhc29jLT5wZWVyLnBlZXJfaG1hY3MgPSBuZXctPnBlZXIucGVlcl9obWFjczsKIAluZXctPnBlZXIucGVlcl9obWFjcyA9IE5VTEw7CiAKLQlzY3RwX2F1dGhfa2V5X3B1dChhc29jLT5hc29jX3NoYXJlZF9rZXkpOwogCXNjdHBfYXV0aF9hc29jX2luaXRfYWN0aXZlX2tleShhc29jLCBHRlBfQVRPTUlDKTsKIH0KIApkaWZmIC0tZ2l0IGEvbmV0L3NjdHAvc21fbWFrZV9jaHVuay5jIGIvbmV0L3NjdHAvc21fbWFrZV9jaHVuay5jCmluZGV4IGU0OWUyMzEuLjA2MzIwYzggMTAwNjQ0Ci0tLSBhL25ldC9zY3RwL3NtX21ha2VfY2h1bmsuYworKysgYi9uZXQvc2N0cC9zbV9tYWtlX2NodW5rLmMKQEAgLTI2MDgsNyArMjYwOCw3IEBACiAKIAkJYWRkcl9wYXJhbSA9IHBhcmFtLnYgKyBzaXplb2Yoc2N0cF9hZGRpcF9wYXJhbV90KTsKIAotCQlhZiA9IHNjdHBfZ2V0X2FmX3NwZWNpZmljKHBhcmFtX3R5cGUyYWYocGFyYW0ucC0+dHlwZSkpOworCQlhZiA9IHNjdHBfZ2V0X2FmX3NwZWNpZmljKHBhcmFtX3R5cGUyYWYoYWRkcl9wYXJhbS0+cC50eXBlKSk7CiAJCWlmIChhZiA9PSBOVUxMKQogCQkJYnJlYWs7CiAKZGlmZiAtLWdpdCBhL25ldC9zY3RwL3NvY2tldC5jIGIvbmV0L3NjdHAvc29ja2V0LmMKaW5kZXggMjYyNWVjYy4uYWFmZTk0YiAxMDA2NDQKLS0tIGEvbmV0L3NjdHAvc29ja2V0LmMKKysrIGIvbmV0L3NjdHAvc29ja2V0LmMKQEAgLTE2MDMsNyArMTYwMyw3IEBACiAJc2N0cF9hc3NvY190IGFzc29jaWQgPSAwOwogCXNjdHBfY21zZ3NfdCBjbXNncyA9IHsgTlVMTCB9OwogCXNjdHBfc2NvcGVfdCBzY29wZTsKLQlib29sIGZpbGxfc2luZm9fdHRsID0gZmFsc2U7CisJYm9vbCBmaWxsX3NpbmZvX3R0bCA9IGZhbHNlLCB3YWl0X2Nvbm5lY3QgPSBmYWxzZTsKIAlzdHJ1Y3Qgc2N0cF9kYXRhbXNnICpkYXRhbXNnOwogCWludCBtc2dfZmxhZ3MgPSBtc2ctPm1zZ19mbGFnczsKIAlfX3UxNiBzaW5mb19mbGFncyA9IDA7CkBAIC0xOTQzLDYgKzE5NDMsNyBAQAogCQlpZiAoZXJyIDwgMCkKIAkJCWdvdG8gb3V0X2ZyZWU7CiAKKwkJd2FpdF9jb25uZWN0ID0gdHJ1ZTsKIAkJcHJfZGVidWcoIiVzOiB3ZSBhc3NvY2lhdGVkIHByaW1pdGl2ZWx5XG4iLCBfX2Z1bmNfXyk7CiAJfQogCkBAIC0xOTgwLDYgKzE5ODEsMTEgQEAKIAlzY3RwX2RhdGFtc2dfcHV0KGRhdGFtc2cpOwogCWVyciA9IG1zZ19sZW47CiAKKwlpZiAodW5saWtlbHkod2FpdF9jb25uZWN0KSkgeworCQl0aW1lbyA9IHNvY2tfc25kdGltZW8oc2ssIG1zZ19mbGFncyAmIE1TR19ET05UV0FJVCk7CisJCXNjdHBfd2FpdF9mb3JfY29ubmVjdChhc29jLCAmdGltZW8pOworCX0KKwogCS8qIElmIHdlIGFyZSBhbHJlYWR5IHBhc3QgQVNTT0NJQVRFLCB0aGUgbG93ZXIKIAkgKiBsYXllcnMgYXJlIHJlc3BvbnNpYmxlIGZvciBhc3NvY2lhdGlvbiBjbGVhbnVwLgogCSAqLwpkaWZmIC0tZ2l0IGEvbmV0L3NvY2tldC5jIGIvbmV0L3NvY2tldC5jCmluZGV4IGEyYzMzYTQuLjQxODc5NWMgMTAwNjQ0Ci0tLSBhL25ldC9zb2NrZXQuYworKysgYi9uZXQvc29ja2V0LmMKQEAgLTg2OSw5ICs4NjksNiBAQAogc3RhdGljIHN0cnVjdCBzb2NrX2lvY2IgKmFsbG9jX3NvY2tfaW9jYihzdHJ1Y3Qga2lvY2IgKmlvY2IsCiAJCQkJCSBzdHJ1Y3Qgc29ja19pb2NiICpzaW9jYikKIHsKLQlpZiAoIWlzX3N5bmNfa2lvY2IoaW9jYikpCi0JCUJVRygpOwotCiAJc2lvY2ItPmtpb2NiID0gaW9jYjsKIAlpb2NiLT5wcml2YXRlID0gc2lvY2I7CiAJcmV0dXJuIHNpb2NiOwpkaWZmIC0tZ2l0IGEvbmV0L3dpcmVsZXNzL25sODAyMTEuYyBiL25ldC93aXJlbGVzcy9ubDgwMjExLmMKaW5kZXggN2NhNGI1MS4uODg4N2M2ZSAxMDA2NDQKLS0tIGEvbmV0L3dpcmVsZXNzL25sODAyMTEuYworKysgYi9uZXQvd2lyZWxlc3Mvbmw4MDIxMS5jCkBAIC0yODU0LDYgKzI4NTQsOSBAQAogCWlmICghcmRldi0+b3BzLT5nZXRfa2V5KQogCQlyZXR1cm4gLUVPUE5PVFNVUFA7CiAKKwlpZiAoIXBhaXJ3aXNlICYmIG1hY19hZGRyICYmICEocmRldi0+d2lwaHkuZmxhZ3MgJiBXSVBIWV9GTEFHX0lCU1NfUlNOKSkKKwkJcmV0dXJuIC1FTk9FTlQ7CisKIAltc2cgPSBubG1zZ19uZXcoTkxNU0dfREVGQVVMVF9TSVpFLCBHRlBfS0VSTkVMKTsKIAlpZiAoIW1zZykKIAkJcmV0dXJuIC1FTk9NRU07CkBAIC0yODczLDEwICsyODc2LDYgQEAKIAkgICAgbmxhX3B1dChtc2csIE5MODAyMTFfQVRUUl9NQUMsIEVUSF9BTEVOLCBtYWNfYWRkcikpCiAJCWdvdG8gbmxhX3B1dF9mYWlsdXJlOwogCi0JaWYgKHBhaXJ3aXNlICYmIG1hY19hZGRyICYmCi0JICAgICEocmRldi0+d2lwaHkuZmxhZ3MgJiBXSVBIWV9GTEFHX0lCU1NfUlNOKSkKLQkJcmV0dXJuIC1FTk9FTlQ7Ci0KIAllcnIgPSByZGV2X2dldF9rZXkocmRldiwgZGV2LCBrZXlfaWR4LCBwYWlyd2lzZSwgbWFjX2FkZHIsICZjb29raWUsCiAJCQkgICBnZXRfa2V5X2NhbGxiYWNrKTsKIApAQCAtMzA0Nyw3ICszMDQ2LDcgQEAKIAl3ZGV2X2xvY2soZGV2LT5pZWVlODAyMTFfcHRyKTsKIAllcnIgPSBubDgwMjExX2tleV9hbGxvd2VkKGRldi0+aWVlZTgwMjExX3B0cik7CiAKLQlpZiAoa2V5LnR5cGUgPT0gTkw4MDIxMV9LRVlUWVBFX1BBSVJXSVNFICYmIG1hY19hZGRyICYmCisJaWYgKGtleS50eXBlID09IE5MODAyMTFfS0VZVFlQRV9HUk9VUCAmJiBtYWNfYWRkciAmJgogCSAgICAhKHJkZXYtPndpcGh5LmZsYWdzICYgV0lQSFlfRkxBR19JQlNTX1JTTikpCiAJCWVyciA9IC1FTk9FTlQ7CiAKZGlmZiAtLWdpdCBhL25ldC93aXJlbGVzcy9yZWcuYyBiL25ldC93aXJlbGVzcy9yZWcuYwppbmRleCA3YjgzMDk4Li5kMzlkMWNiIDEwMDY0NAotLS0gYS9uZXQvd2lyZWxlc3MvcmVnLmMKKysrIGIvbmV0L3dpcmVsZXNzL3JlZy5jCkBAIC0xNTMwLDQ1ICsxNTMwLDQwIEBACiAKIHN0YXRpYyBib29sIHJlZ193ZGV2X2NoYW5fdmFsaWQoc3RydWN0IHdpcGh5ICp3aXBoeSwgc3RydWN0IHdpcmVsZXNzX2RldiAqd2RldikKIHsKLQlzdHJ1Y3QgaWVlZTgwMjExX2NoYW5uZWwgKmNoOwogCXN0cnVjdCBjZmc4MDIxMV9jaGFuX2RlZiBjaGFuZGVmOwogCXN0cnVjdCBjZmc4MDIxMV9yZWdpc3RlcmVkX2RldmljZSAqcmRldiA9IHdpcGh5X3RvX3JkZXYod2lwaHkpOwotCWJvb2wgcmV0ID0gdHJ1ZTsKKwllbnVtIG5sODAyMTFfaWZ0eXBlIGlmdHlwZTsKIAogCXdkZXZfbG9jayh3ZGV2KTsKKwlpZnR5cGUgPSB3ZGV2LT5pZnR5cGU7CiAKKwkvKiBtYWtlIHN1cmUgdGhlIGludGVyZmFjZSBpcyBhY3RpdmUgKi8KIAlpZiAoIXdkZXYtPm5ldGRldiB8fCAhbmV0aWZfcnVubmluZyh3ZGV2LT5uZXRkZXYpKQotCQlnb3RvIG91dDsKKwkJZ290byB3ZGV2X2luYWN0aXZlX3VubG9jazsKIAotCXN3aXRjaCAod2Rldi0+aWZ0eXBlKSB7CisJc3dpdGNoIChpZnR5cGUpIHsKIAljYXNlIE5MODAyMTFfSUZUWVBFX0FQOgogCWNhc2UgTkw4MDIxMV9JRlRZUEVfUDJQX0dPOgogCQlpZiAoIXdkZXYtPmJlYWNvbl9pbnRlcnZhbCkKLQkJCWdvdG8gb3V0OwotCi0JCXJldCA9IGNmZzgwMjExX3JlZ19jYW5fYmVhY29uKHdpcGh5LAotCQkJCQkgICAgICAmd2Rldi0+Y2hhbmRlZiwgd2Rldi0+aWZ0eXBlKTsKKwkJCWdvdG8gd2Rldl9pbmFjdGl2ZV91bmxvY2s7CisJCWNoYW5kZWYgPSB3ZGV2LT5jaGFuZGVmOwogCQlicmVhazsKIAljYXNlIE5MODAyMTFfSUZUWVBFX0FESE9DOgogCQlpZiAoIXdkZXYtPnNzaWRfbGVuKQotCQkJZ290byBvdXQ7Ci0KLQkJcmV0ID0gY2ZnODAyMTFfcmVnX2Nhbl9iZWFjb24od2lwaHksCi0JCQkJCSAgICAgICZ3ZGV2LT5jaGFuZGVmLCB3ZGV2LT5pZnR5cGUpOworCQkJZ290byB3ZGV2X2luYWN0aXZlX3VubG9jazsKKwkJY2hhbmRlZiA9IHdkZXYtPmNoYW5kZWY7CiAJCWJyZWFrOwogCWNhc2UgTkw4MDIxMV9JRlRZUEVfU1RBVElPTjoKIAljYXNlIE5MODAyMTFfSUZUWVBFX1AyUF9DTElFTlQ6CiAJCWlmICghd2Rldi0+Y3VycmVudF9ic3MgfHwKIAkJICAgICF3ZGV2LT5jdXJyZW50X2Jzcy0+cHViLmNoYW5uZWwpCi0JCQlnb3RvIG91dDsKKwkJCWdvdG8gd2Rldl9pbmFjdGl2ZV91bmxvY2s7CiAKLQkJY2ggPSB3ZGV2LT5jdXJyZW50X2Jzcy0+cHViLmNoYW5uZWw7Ci0JCWlmIChyZGV2LT5vcHMtPmdldF9jaGFubmVsICYmCi0JCSAgICAhcmRldl9nZXRfY2hhbm5lbChyZGV2LCB3ZGV2LCAmY2hhbmRlZikpCi0JCQlyZXQgPSBjZmc4MDIxMV9jaGFuZGVmX3VzYWJsZSh3aXBoeSwgJmNoYW5kZWYsCi0JCQkJCQkgICAgICBJRUVFODAyMTFfQ0hBTl9ESVNBQkxFRCk7Ci0JCWVsc2UKLQkJCXJldCA9ICEoY2gtPmZsYWdzICYgSUVFRTgwMjExX0NIQU5fRElTQUJMRUQpOworCQlpZiAoIXJkZXYtPm9wcy0+Z2V0X2NoYW5uZWwgfHwKKwkJICAgIHJkZXZfZ2V0X2NoYW5uZWwocmRldiwgd2RldiwgJmNoYW5kZWYpKQorCQkJY2ZnODAyMTFfY2hhbmRlZl9jcmVhdGUoJmNoYW5kZWYsCisJCQkJCQl3ZGV2LT5jdXJyZW50X2Jzcy0+cHViLmNoYW5uZWwsCisJCQkJCQlOTDgwMjExX0NIQU5fTk9fSFQpOwogCQlicmVhazsKIAljYXNlIE5MODAyMTFfSUZUWVBFX01PTklUT1I6CiAJY2FzZSBOTDgwMjExX0lGVFlQRV9BUF9WTEFOOgpAQCAtMTU4MSw5ICsxNTc2LDI2IEBACiAJCWJyZWFrOwogCX0KIAotb3V0OgogCXdkZXZfdW5sb2NrKHdkZXYpOwotCXJldHVybiByZXQ7CisKKwlzd2l0Y2ggKGlmdHlwZSkgeworCWNhc2UgTkw4MDIxMV9JRlRZUEVfQVA6CisJY2FzZSBOTDgwMjExX0lGVFlQRV9QMlBfR086CisJY2FzZSBOTDgwMjExX0lGVFlQRV9BREhPQzoKKwkJcmV0dXJuIGNmZzgwMjExX3JlZ19jYW5fYmVhY29uKHdpcGh5LCAmY2hhbmRlZiwgaWZ0eXBlKTsKKwljYXNlIE5MODAyMTFfSUZUWVBFX1NUQVRJT046CisJY2FzZSBOTDgwMjExX0lGVFlQRV9QMlBfQ0xJRU5UOgorCQlyZXR1cm4gY2ZnODAyMTFfY2hhbmRlZl91c2FibGUod2lwaHksICZjaGFuZGVmLAorCQkJCQkgICAgICAgSUVFRTgwMjExX0NIQU5fRElTQUJMRUQpOworCWRlZmF1bHQ6CisJCWJyZWFrOworCX0KKworCXJldHVybiB0cnVlOworCit3ZGV2X2luYWN0aXZlX3VubG9jazoKKwl3ZGV2X3VubG9jayh3ZGV2KTsKKwlyZXR1cm4gdHJ1ZTsKIH0KIAogc3RhdGljIHZvaWQgcmVnX2xlYXZlX2ludmFsaWRfY2hhbnMoc3RydWN0IHdpcGh5ICp3aXBoeSkKZGlmZiAtLWdpdCBhL25ldC93aXJlbGVzcy91dGlsLmMgYi9uZXQvd2lyZWxlc3MvdXRpbC5jCmluZGV4IGQwYWM3OTUuLjU0ODhjMzYgMTAwNjQ0Ci0tLSBhL25ldC93aXJlbGVzcy91dGlsLmMKKysrIGIvbmV0L3dpcmVsZXNzL3V0aWwuYwpAQCAtMzA4LDYgKzMwOCwxMiBAQAogCQlnb3RvIG91dDsKIAl9CiAKKwlpZiAoaWVlZTgwMjExX2lzX21nbXQoZmMpKSB7CisJCWlmIChpZWVlODAyMTFfaGFzX29yZGVyKGZjKSkKKwkJCWhkcmxlbiArPSBJRUVFODAyMTFfSFRfQ1RMX0xFTjsKKwkJZ290byBvdXQ7CisJfQorCiAJaWYgKGllZWU4MDIxMV9pc19jdGwoZmMpKSB7CiAJCS8qCiAJCSAqIEFDSyBhbmQgQ1RTIGFyZSAxMCBieXRlcywgYWxsIG90aGVycyAxNi4gVG8gc2VlIGhvdwpkaWZmIC0tZ2l0IGEvc2FtcGxlcy9icGYvdGVzdF9tYXBzLmMgYi9zYW1wbGVzL2JwZi90ZXN0X21hcHMuYwppbmRleCBlMjg2YjQyLi42Mjk5ZWU5IDEwMDY0NAotLS0gYS9zYW1wbGVzL2JwZi90ZXN0X21hcHMuYworKysgYi9zYW1wbGVzL2JwZi90ZXN0X21hcHMuYwpAQCAtNjksOSArNjksOSBAQAogCiAJLyogaXRlcmF0ZSBvdmVyIHR3byBlbGVtZW50cyAqLwogCWFzc2VydChicGZfZ2V0X25leHRfa2V5KG1hcF9mZCwgJmtleSwgJm5leHRfa2V5KSA9PSAwICYmCi0JICAgICAgIG5leHRfa2V5ID09IDIpOworCSAgICAgICAobmV4dF9rZXkgPT0gMSB8fCBuZXh0X2tleSA9PSAyKSk7CiAJYXNzZXJ0KGJwZl9nZXRfbmV4dF9rZXkobWFwX2ZkLCAmbmV4dF9rZXksICZuZXh0X2tleSkgPT0gMCAmJgotCSAgICAgICBuZXh0X2tleSA9PSAxKTsKKwkgICAgICAgKG5leHRfa2V5ID09IDEgfHwgbmV4dF9rZXkgPT0gMikpOwogCWFzc2VydChicGZfZ2V0X25leHRfa2V5KG1hcF9mZCwgJm5leHRfa2V5LCAmbmV4dF9rZXkpID09IC0xICYmCiAJICAgICAgIGVycm5vID09IEVOT0VOVCk7CiAKZGlmZiAtLWdpdCBhL3NjcmlwdHMvcmVjb3JkbWNvdW50LnBsIGIvc2NyaXB0cy9yZWNvcmRtY291bnQucGwKaW5kZXggNTZlYTk5YS4uNTM3YzM4YyAxMDA3NTUKLS0tIGEvc2NyaXB0cy9yZWNvcmRtY291bnQucGwKKysrIGIvc2NyaXB0cy9yZWNvcmRtY291bnQucGwKQEAgLTI1NSw3ICsyNTUsNiBAQAogICAgICMgZm9yY2UgZmxhZ3MgZm9yIHRoaXMgYXJjaAogICAgICRsZCAuPSAiIC1tIHNobGVsZl9saW51eCI7CiAgICAgJG9iamNvcHkgLj0gIiAtTyBlbGYzMi1zaC1saW51eCI7Ci0gICAgJGNjIC49ICIgLW0zMiI7CiAKIH0gZWxzaWYgKCRhcmNoIGVxICJwb3dlcnBjIikgewogICAgICRsb2NhbF9yZWdleCA9ICJeWzAtOWEtZkEtRl0rXFxzK3RcXHMrKFxcLj9cXFMrKSI7CmRpZmYgLS1naXQgYS9zb3VuZC9jb3JlL3NlcS9zZXFfZHVtbXkuYyBiL3NvdW5kL2NvcmUvc2VxL3NlcV9kdW1teS5jCmluZGV4IGVjNjY3ZjEuLjVkOTA1ZDkgMTAwNjQ0Ci0tLSBhL3NvdW5kL2NvcmUvc2VxL3NlcV9kdW1teS5jCisrKyBiL3NvdW5kL2NvcmUvc2VxL3NlcV9kdW1teS5jCkBAIC04MiwzNiArODIsNiBAQAogc3RhdGljIGludCBteV9jbGllbnQgPSAtMTsKIAogLyoKLSAqIHVudXNlIGNhbGxiYWNrIC0gc2VuZCBBTExfU09VTkRTX09GRiBhbmQgUkVTRVRfQ09OVFJPTExFUlMgZXZlbnRzCi0gKiB0byBzdWJzY3JpYmVycy4KLSAqIE5vdGU6IHRoaXMgY2FsbGJhY2sgaXMgY2FsbGVkIG9ubHkgYWZ0ZXIgYWxsIHN1YnNjcmliZXJzIGFyZSByZW1vdmVkLgotICovCi1zdGF0aWMgaW50Ci1kdW1teV91bnVzZSh2b2lkICpwcml2YXRlX2RhdGEsIHN0cnVjdCBzbmRfc2VxX3BvcnRfc3Vic2NyaWJlICppbmZvKQotewotCXN0cnVjdCBzbmRfc2VxX2R1bW15X3BvcnQgKnA7Ci0JaW50IGk7Ci0Jc3RydWN0IHNuZF9zZXFfZXZlbnQgZXY7Ci0KLQlwID0gcHJpdmF0ZV9kYXRhOwotCW1lbXNldCgmZXYsIDAsIHNpemVvZihldikpOwotCWlmIChwLT5kdXBsZXgpCi0JCWV2LnNvdXJjZS5wb3J0ID0gcC0+Y29ubmVjdDsKLQllbHNlCi0JCWV2LnNvdXJjZS5wb3J0ID0gcC0+cG9ydDsKLQlldi5kZXN0LmNsaWVudCA9IFNORFJWX1NFUV9BRERSRVNTX1NVQlNDUklCRVJTOwotCWV2LnR5cGUgPSBTTkRSVl9TRVFfRVZFTlRfQ09OVFJPTExFUjsKLQlmb3IgKGkgPSAwOyBpIDwgMTY7IGkrKykgewotCQlldi5kYXRhLmNvbnRyb2wuY2hhbm5lbCA9IGk7Ci0JCWV2LmRhdGEuY29udHJvbC5wYXJhbSA9IE1JRElfQ1RMX0FMTF9TT1VORFNfT0ZGOwotCQlzbmRfc2VxX2tlcm5lbF9jbGllbnRfZGlzcGF0Y2gocC0+Y2xpZW50LCAmZXYsIDAsIDApOwotCQlldi5kYXRhLmNvbnRyb2wucGFyYW0gPSBNSURJX0NUTF9SRVNFVF9DT05UUk9MTEVSUzsKLQkJc25kX3NlcV9rZXJuZWxfY2xpZW50X2Rpc3BhdGNoKHAtPmNsaWVudCwgJmV2LCAwLCAwKTsKLQl9Ci0JcmV0dXJuIDA7Ci19Ci0KLS8qCiAgKiBldmVudCBpbnB1dCBjYWxsYmFjayAtIGp1c3QgcmVkaXJlY3QgZXZlbnRzIHRvIHN1YnNjcmliZXJzCiAgKi8KIHN0YXRpYyBpbnQKQEAgLTE3NSw3ICsxNDUsNiBAQAogCQl8IFNORFJWX1NFUV9QT1JUX1RZUEVfUE9SVDsKIAltZW1zZXQoJnBjYiwgMCwgc2l6ZW9mKHBjYikpOwogCXBjYi5vd25lciA9IFRISVNfTU9EVUxFOwotCXBjYi51bnVzZSA9IGR1bW15X3VudXNlOwogCXBjYi5ldmVudF9pbnB1dCA9IGR1bW15X2lucHV0OwogCXBjYi5wcml2YXRlX2ZyZWUgPSBkdW1teV9mcmVlOwogCXBjYi5wcml2YXRlX2RhdGEgPSByZWM7CmRpZmYgLS1naXQgYS9zb3VuZC9maXJld2lyZS9hbWR0cC5jIGIvc291bmQvZmlyZXdpcmUvYW1kdHAuYwppbmRleCAzYmFkYzcwLi4wZDU4MDE4IDEwMDY0NAotLS0gYS9zb3VuZC9maXJld2lyZS9hbWR0cC5jCisrKyBiL3NvdW5kL2ZpcmV3aXJlL2FtZHRwLmMKQEAgLTIxLDcgKzIxLDE5IEBACiAjZGVmaW5lIENZQ0xFU19QRVJfU0VDT05ECTgwMDAKICNkZWZpbmUgVElDS1NfUEVSX1NFQ09ORAkoVElDS1NfUEVSX0NZQ0xFICogQ1lDTEVTX1BFUl9TRUNPTkQpCiAKLSNkZWZpbmUgVFJBTlNGRVJfREVMQVlfVElDS1MJMHgyZTAwIC8qIDQ3OS4xNyDCtXMgKi8KKy8qCisgKiBOb21pbmFsbHkgMzEyNSBieXRlcy9zZWNvbmQsIGJ1dCB0aGUgTUlESSBwb3J0J3MgY2xvY2sgbWlnaHQgYmUKKyAqIDElIHRvbyBzbG93LCBhbmQgdGhlIGJ1cyBjbG9jayAxMDAgcHBtIHRvbyBmYXN0LgorICovCisjZGVmaW5lIE1JRElfQllURVNfUEVSX1NFQ09ORAkzMDkzCisKKy8qCisgKiBTZXZlcmFsIGRldmljZXMgbG9vayBvbmx5IGF0IHRoZSBmaXJzdCBlaWdodCBkYXRhIGJsb2Nrcy4KKyAqIEluIGFueSBjYXNlLCB0aGlzIGlzIG1vcmUgdGhhbiBlbm91Z2ggZm9yIHRoZSBNSURJIGRhdGEgcmF0ZS4KKyAqLworI2RlZmluZSBNQVhfTUlESV9SWF9CTE9DS1MJOAorCisjZGVmaW5lIFRSQU5TRkVSX0RFTEFZX1RJQ0tTCTB4MmUwMCAvKiA0NzkuMTcgw4LCtXMgKi8KIAogLyogaXNvY2hyb25vdXMgaGVhZGVyIHBhcmFtZXRlcnMgKi8KICNkZWZpbmUgSVNPX0RBVEFfTEVOR1RIX1NISUZUCTE2CkBAIC03OCw4ICs5MCw2IEBACiAJcy0+Y2FsbGJhY2tlZCA9IGZhbHNlOwogCXMtPnN5bmNfc2xhdmUgPSBOVUxMOwogCi0Jcy0+cnhfYmxvY2tzX2Zvcl9taWRpID0gVUlOVF9NQVg7Ci0KIAlyZXR1cm4gMDsKIH0KIEVYUE9SVF9TWU1CT0woYW1kdHBfc3RyZWFtX2luaXQpOwpAQCAtMjIyLDYgKzIzMiwxNCBAQAogCWZvciAoaSA9IDA7IGkgPCBwY21fY2hhbm5lbHM7IGkrKykKIAkJcy0+cGNtX3Bvc2l0aW9uc1tpXSA9IGk7CiAJcy0+bWlkaV9wb3NpdGlvbiA9IHMtPnBjbV9jaGFubmVsczsKKworCS8qCisJICogV2UgZG8gbm90IGtub3cgdGhlIGFjdHVhbCBNSURJIEZJRk8gc2l6ZSBvZiBtb3N0IGRldmljZXMuICBKdXN0CisJICogYXNzdW1lIHR3byBieXRlcywgaS5lLiwgb25lIGJ5dGUgY2FuIGJlIHJlY2VpdmVkIG92ZXIgdGhlIGJ1cyB3aGlsZQorCSAqIHRoZSBwcmV2aW91cyBvbmUgaXMgdHJhbnNtaXR0ZWQgb3ZlciBNSURJLgorCSAqIChUaGUgdmFsdWUgaGVyZSBpcyBhZGp1c3RlZCBmb3IgbWlkaV9yYXRlbGltaXRfcGVyX3BhY2tldCgpLikKKwkgKi8KKwlzLT5taWRpX2ZpZm9fbGltaXQgPSByYXRlIC0gTUlESV9CWVRFU19QRVJfU0VDT05EICogcy0+c3l0X2ludGVydmFsICsgMTsKIH0KIEVYUE9SVF9TWU1CT0woYW1kdHBfc3RyZWFtX3NldF9wYXJhbWV0ZXJzKTsKIApAQCAtNDYzLDYgKzQ4MSwzNiBAQAogCX0KIH0KIAorLyoKKyAqIFRvIGF2b2lkIHNlbmRpbmcgTUlESSBieXRlcyBhdCB0b28gaGlnaCBhIHJhdGUsIGFzc3VtZSB0aGF0IHRoZSByZWNlaXZpbmcKKyAqIGRldmljZSBoYXMgYSBGSUZPLCBhbmQgdHJhY2sgaG93IG11Y2ggaXQgaXMgZmlsbGVkLiAgVGhpcyB2YWx1ZXMgaW5jcmVhc2VzCisgKiBieSBvbmUgd2hlbmV2ZXIgd2Ugc2VuZCBvbmUgYnl0ZSBpbiBhIHBhY2tldCwgYnV0IHRoZSBGSUZPIGVtcHRpZXMgYXQKKyAqIGEgY29uc3RhbnQgcmF0ZSBpbmRlcGVuZGVudCBvZiBvdXIgcGFja2V0IHJhdGUuICBPbmUgcGFja2V0IGhhcyBzeXRfaW50ZXJ2YWwKKyAqIHNhbXBsZXMsIHNvIHRoZSBudW1iZXIgb2YgYnl0ZXMgdGhhdCBlbXB0eSBvdXQgb2YgdGhlIEZJRk8sIHBlciBwYWNrZXQoISksCisgKiBpcyBNSURJX0JZVEVTX1BFUl9TRUNPTkQgKiBzeXRfaW50ZXJ2YWwgLyBzYW1wbGVfcmF0ZS4gIFRvIGF2b2lkIHN0b3JpbmcKKyAqIGZyYWN0aW9uYWwgdmFsdWVzLCB0aGUgdmFsdWVzIGluIG1pZGlfZmlmb191c2VkW10gYXJlIG1lYXN1cmVkIGluIGJ5dGVzCisgKiBtdWx0aXBsaWVkIGJ5IHRoZSBzYW1wbGUgcmF0ZS4KKyAqLworc3RhdGljIGJvb2wgbWlkaV9yYXRlbGltaXRfcGVyX3BhY2tldChzdHJ1Y3QgYW1kdHBfc3RyZWFtICpzLCB1bnNpZ25lZCBpbnQgcG9ydCkKK3sKKwlpbnQgdXNlZDsKKworCXVzZWQgPSBzLT5taWRpX2ZpZm9fdXNlZFtwb3J0XTsKKwlpZiAodXNlZCA9PSAwKSAvKiBjb21tb24gc2hvcnRjdXQgKi8KKwkJcmV0dXJuIHRydWU7CisKKwl1c2VkIC09IE1JRElfQllURVNfUEVSX1NFQ09ORCAqIHMtPnN5dF9pbnRlcnZhbDsKKwl1c2VkID0gbWF4KHVzZWQsIDApOworCXMtPm1pZGlfZmlmb191c2VkW3BvcnRdID0gdXNlZDsKKworCXJldHVybiB1c2VkIDwgcy0+bWlkaV9maWZvX2xpbWl0OworfQorCitzdGF0aWMgdm9pZCBtaWRpX3JhdGVfdXNlX29uZV9ieXRlKHN0cnVjdCBhbWR0cF9zdHJlYW0gKnMsIHVuc2lnbmVkIGludCBwb3J0KQoreworCXMtPm1pZGlfZmlmb191c2VkW3BvcnRdICs9IGFtZHRwX3JhdGVfdGFibGVbcy0+c2ZjXTsKK30KKwogc3RhdGljIHZvaWQgYW1kdHBfZmlsbF9taWRpKHN0cnVjdCBhbWR0cF9zdHJlYW0gKnMsCiAJCQkgICAgX19iZTMyICpidWZmZXIsIHVuc2lnbmVkIGludCBmcmFtZXMpCiB7CkBAIC00NzAsMTYgKzUxOCwyMSBAQAogCXU4ICpiOwogCiAJZm9yIChmID0gMDsgZiA8IGZyYW1lczsgZisrKSB7Ci0JCWJ1ZmZlcltzLT5taWRpX3Bvc2l0aW9uXSA9IDA7CiAJCWIgPSAodTggKikmYnVmZmVyW3MtPm1pZGlfcG9zaXRpb25dOwogCiAJCXBvcnQgPSAocy0+ZGF0YV9ibG9ja19jb3VudGVyICsgZikgJSA4OwotCQlpZiAoKGYgPj0gcy0+cnhfYmxvY2tzX2Zvcl9taWRpKSB8fAotCQkgICAgKHMtPm1pZGlbcG9ydF0gPT0gTlVMTCkgfHwKLQkJICAgIChzbmRfcmF3bWlkaV90cmFuc21pdChzLT5taWRpW3BvcnRdLCBiICsgMSwgMSkgPD0gMCkpCi0JCQliWzBdID0gMHg4MDsKLQkJZWxzZQorCQlpZiAoZiA8IE1BWF9NSURJX1JYX0JMT0NLUyAmJgorCQkgICAgbWlkaV9yYXRlbGltaXRfcGVyX3BhY2tldChzLCBwb3J0KSAmJgorCQkgICAgcy0+bWlkaVtwb3J0XSAhPSBOVUxMICYmCisJCSAgICBzbmRfcmF3bWlkaV90cmFuc21pdChzLT5taWRpW3BvcnRdLCAmYlsxXSwgMSkgPT0gMSkgeworCQkJbWlkaV9yYXRlX3VzZV9vbmVfYnl0ZShzLCBwb3J0KTsKIAkJCWJbMF0gPSAweDgxOworCQl9IGVsc2UgeworCQkJYlswXSA9IDB4ODA7CisJCQliWzFdID0gMDsKKwkJfQorCQliWzJdID0gMDsKKwkJYlszXSA9IDA7CiAKIAkJYnVmZmVyICs9IHMtPmRhdGFfYmxvY2tfcXVhZGxldHM7CiAJfQpkaWZmIC0tZ2l0IGEvc291bmQvZmlyZXdpcmUvYW1kdHAuaCBiL3NvdW5kL2ZpcmV3aXJlL2FtZHRwLmgKaW5kZXggZTZlODkyNi4uOGEwM2E5MSAxMDA2NDQKLS0tIGEvc291bmQvZmlyZXdpcmUvYW1kdHAuaAorKysgYi9zb3VuZC9maXJld2lyZS9hbWR0cC5oCkBAIC0xNDgsMTMgKzE0OCwxMiBAQAogCWJvb2wgZG91YmxlX3BjbV9mcmFtZXM7CiAKIAlzdHJ1Y3Qgc25kX3Jhd21pZGlfc3Vic3RyZWFtICptaWRpW0FNRFRQX01BWF9DSEFOTkVMU19GT1JfTUlESSAqIDhdOworCWludCBtaWRpX2ZpZm9fbGltaXQ7CisJaW50IG1pZGlfZmlmb191c2VkW0FNRFRQX01BWF9DSEFOTkVMU19GT1JfTUlESSAqIDhdOwogCiAJLyogcXVpcms6IGZpeGVkIGludGVydmFsIG9mIGRiYyBiZXR3ZWVuIHByZXZpb3MvY3VycmVudCBwYWNrZXRzLiAqLwogCXVuc2lnbmVkIGludCB0eF9kYmNfaW50ZXJ2YWw7CiAKLQkvKiBxdWlyazogdGhlIGZpcnN0IGNvdW50IG9mIGRhdGEgYmxvY2tzIGluIGFuIHJ4IHBhY2tldCBmb3IgTUlESSAqLwotCXVuc2lnbmVkIGludCByeF9ibG9ja3NfZm9yX21pZGk7Ci0KIAlib29sIGNhbGxiYWNrZWQ7CiAJd2FpdF9xdWV1ZV9oZWFkX3QgY2FsbGJhY2tfd2FpdDsKIAlzdHJ1Y3QgYW1kdHBfc3RyZWFtICpzeW5jX3NsYXZlOwpkaWZmIC0tZ2l0IGEvc291bmQvZmlyZXdpcmUvYmVib2IvYmVib2Jfc3RyZWFtLmMgYi9zb3VuZC9maXJld2lyZS9iZWJvYi9iZWJvYl9zdHJlYW0uYwppbmRleCAxYWFiMGEzMi4uMGViY2FiZiAxMDA2NDQKLS0tIGEvc291bmQvZmlyZXdpcmUvYmVib2IvYmVib2Jfc3RyZWFtLmMKKysrIGIvc291bmQvZmlyZXdpcmUvYmVib2IvYmVib2Jfc3RyZWFtLmMKQEAgLTQ4NCwxMyArNDg0LDYgQEAKIAkJYW1kdHBfc3RyZWFtX2Rlc3Ryb3koJmJlYm9iLT5yeF9zdHJlYW0pOwogCQlkZXN0cm95X2JvdGhfY29ubmVjdGlvbnMoYmVib2IpOwogCX0KLQkvKgotCSAqIFRoZSBmaXJtd2FyZSBmb3IgdGhlc2UgZGV2aWNlcyBpZ25vcmUgTUlESSBtZXNzYWdlcyBpbiBtb3JlIHRoYW4KLQkgKiBmaXJzdCA4IGRhdGEgYmxvY2tzIG9mIGFuIHJlY2VpdmVkIEFNRFRQIHBhY2tldC4KLQkgKi8KLQlpZiAoYmVib2ItPnNwZWMgPT0gJm1hdWRpb19mdzQxMF9zcGVjIHx8Ci0JICAgIGJlYm9iLT5zcGVjID09ICZtYXVkaW9fc3BlY2lhbF9zcGVjKQotCQliZWJvYi0+cnhfc3RyZWFtLnJ4X2Jsb2Nrc19mb3JfbWlkaSA9IDg7CiBlbmQ6CiAJcmV0dXJuIGVycjsKIH0KZGlmZiAtLWdpdCBhL3NvdW5kL2ZpcmV3aXJlL2ZpcmV3b3Jrcy9maXJld29ya3Nfc3RyZWFtLmMgYi9zb3VuZC9maXJld2lyZS9maXJld29ya3MvZmlyZXdvcmtzX3N0cmVhbS5jCmluZGV4IGI5ODVmYzUuLjRmNDQwZTEgMTAwNjQ0Ci0tLSBhL3NvdW5kL2ZpcmV3aXJlL2ZpcmV3b3Jrcy9maXJld29ya3Nfc3RyZWFtLmMKKysrIGIvc291bmQvZmlyZXdpcmUvZmlyZXdvcmtzL2ZpcmV3b3Jrc19zdHJlYW0uYwpAQCAtMTc5LDExICsxNzksNiBAQAogCQlkZXN0cm95X3N0cmVhbShlZncsICZlZnctPnR4X3N0cmVhbSk7CiAJCWdvdG8gZW5kOwogCX0KLQkvKgotCSAqIEZpcmV3b3JrcyBpZ25vcmVzIE1JREkgbWVzc2FnZXMgaW4gbW9yZSB0aGFuIGZpcnN0IDggZGF0YQotCSAqIGJsb2NrcyBvZiBhbiByZWNlaXZlZCBBTURUUCBwYWNrZXQuCi0JICovCi0JZWZ3LT5yeF9zdHJlYW0ucnhfYmxvY2tzX2Zvcl9taWRpID0gODsKIAogCS8qIHNldCBJRUM2MTg4MyBjb21wbGlhbnQgbW9kZSAoYWN0dWFsbHkgbm90IGZ1bGx5IGNvbXBsaWFudC4uLikgKi8KIAllcnIgPSBzbmRfZWZ3X2NvbW1hbmRfc2V0X3R4X21vZGUoZWZ3LCBTTkRfRUZXX1RSQU5TUE9SVF9NT0RFX0lFQzYxODgzKTsKZGlmZiAtLWdpdCBhL3NvdW5kL2kyYy9vdGhlci9hazQxMTMuYyBiL3NvdW5kL2kyYy9vdGhlci9hazQxMTMuYwppbmRleCAxYTNhNmZhLi5jNmJiYTk5IDEwMDY0NAotLS0gYS9zb3VuZC9pMmMvb3RoZXIvYWs0MTEzLmMKKysrIGIvc291bmQvaTJjL290aGVyL2FrNDExMy5jCkBAIC01Niw4ICs1Niw3IEBACiAKIHN0YXRpYyB2b2lkIHNuZF9hazQxMTNfZnJlZShzdHJ1Y3QgYWs0MTEzICpjaGlwKQogewotCWNoaXAtPmluaXQgPSAxOwkvKiBkb24ndCBzY2hlZHVsZSBuZXcgd29yayAqLwotCW1iKCk7CisJYXRvbWljX2luYygmY2hpcC0+d3FfcHJvY2Vzc2luZyk7CS8qIGRvbid0IHNjaGVkdWxlIG5ldyB3b3JrICovCiAJY2FuY2VsX2RlbGF5ZWRfd29ya19zeW5jKCZjaGlwLT53b3JrKTsKIAlrZnJlZShjaGlwKTsKIH0KQEAgLTg5LDYgKzg4LDcgQEAKIAljaGlwLT53cml0ZSA9IHdyaXRlOwogCWNoaXAtPnByaXZhdGVfZGF0YSA9IHByaXZhdGVfZGF0YTsKIAlJTklUX0RFTEFZRURfV09SSygmY2hpcC0+d29yaywgYWs0MTEzX3N0YXRzKTsKKwlhdG9taWNfc2V0KCZjaGlwLT53cV9wcm9jZXNzaW5nLCAwKTsKIAogCWZvciAocmVnID0gMDsgcmVnIDwgQUs0MTEzX1dSSVRBQkxFX1JFR1MgOyByZWcrKykKIAkJY2hpcC0+cmVnbWFwW3JlZ10gPSBwZ21bcmVnXTsKQEAgLTEzOSwxMyArMTM5LDExIEBACiAKIHZvaWQgc25kX2FrNDExM19yZWluaXQoc3RydWN0IGFrNDExMyAqY2hpcCkKIHsKLQljaGlwLT5pbml0ID0gMTsKLQltYigpOwotCWZsdXNoX2RlbGF5ZWRfd29yaygmY2hpcC0+d29yayk7CisJaWYgKGF0b21pY19pbmNfcmV0dXJuKCZjaGlwLT53cV9wcm9jZXNzaW5nKSA9PSAxKQorCQljYW5jZWxfZGVsYXllZF93b3JrX3N5bmMoJmNoaXAtPndvcmspOwogCWFrNDExM19pbml0X3JlZ3MoY2hpcCk7CiAJLyogYnJpbmcgdXAgc3RhdGlzdGljcyAvIGV2ZW50IHF1ZWluZyAqLwotCWNoaXAtPmluaXQgPSAwOwotCWlmIChjaGlwLT5rY3Rsc1swXSkKKwlpZiAoYXRvbWljX2RlY19hbmRfdGVzdCgmY2hpcC0+d3FfcHJvY2Vzc2luZykpCiAJCXNjaGVkdWxlX2RlbGF5ZWRfd29yaygmY2hpcC0+d29yaywgSFogLyAxMCk7CiB9CiBFWFBPUlRfU1lNQk9MX0dQTChzbmRfYWs0MTEzX3JlaW5pdCk7CkBAIC02MzIsOCArNjMwLDkgQEAKIHsKIAlzdHJ1Y3QgYWs0MTEzICpjaGlwID0gY29udGFpbmVyX29mKHdvcmssIHN0cnVjdCBhazQxMTMsIHdvcmsud29yayk7CiAKLQlpZiAoIWNoaXAtPmluaXQpCisJaWYgKGF0b21pY19pbmNfcmV0dXJuKCZjaGlwLT53cV9wcm9jZXNzaW5nKSA9PSAxKQogCQlzbmRfYWs0MTEzX2NoZWNrX3JhdGVfYW5kX2Vycm9ycyhjaGlwLCBjaGlwLT5jaGVja19mbGFncyk7CiAKLQlzY2hlZHVsZV9kZWxheWVkX3dvcmsoJmNoaXAtPndvcmssIEhaIC8gMTApOworCWlmIChhdG9taWNfZGVjX2FuZF90ZXN0KCZjaGlwLT53cV9wcm9jZXNzaW5nKSkKKwkJc2NoZWR1bGVfZGVsYXllZF93b3JrKCZjaGlwLT53b3JrLCBIWiAvIDEwKTsKIH0KZGlmZiAtLWdpdCBhL3NvdW5kL2kyYy9vdGhlci9hazQxMTQuYyBiL3NvdW5kL2kyYy9vdGhlci9hazQxMTQuYwppbmRleCBjN2Y1NjMzLi5iNzBlNmVjIDEwMDY0NAotLS0gYS9zb3VuZC9pMmMvb3RoZXIvYWs0MTE0LmMKKysrIGIvc291bmQvaTJjL290aGVyL2FrNDExNC5jCkBAIC02Niw4ICs2Niw3IEBACiAKIHN0YXRpYyB2b2lkIHNuZF9hazQxMTRfZnJlZShzdHJ1Y3QgYWs0MTE0ICpjaGlwKQogewotCWNoaXAtPmluaXQgPSAxOwkvKiBkb24ndCBzY2hlZHVsZSBuZXcgd29yayAqLwotCW1iKCk7CisJYXRvbWljX2luYygmY2hpcC0+d3FfcHJvY2Vzc2luZyk7CS8qIGRvbid0IHNjaGVkdWxlIG5ldyB3b3JrICovCiAJY2FuY2VsX2RlbGF5ZWRfd29ya19zeW5jKCZjaGlwLT53b3JrKTsKIAlrZnJlZShjaGlwKTsKIH0KQEAgLTEwMCw2ICs5OSw3IEBACiAJY2hpcC0+d3JpdGUgPSB3cml0ZTsKIAljaGlwLT5wcml2YXRlX2RhdGEgPSBwcml2YXRlX2RhdGE7CiAJSU5JVF9ERUxBWUVEX1dPUksoJmNoaXAtPndvcmssIGFrNDExNF9zdGF0cyk7CisJYXRvbWljX3NldCgmY2hpcC0+d3FfcHJvY2Vzc2luZywgMCk7CiAKIAlmb3IgKHJlZyA9IDA7IHJlZyA8IDY7IHJlZysrKQogCQljaGlwLT5yZWdtYXBbcmVnXSA9IHBnbVtyZWddOwpAQCAtMTUyLDEzICsxNTIsMTEgQEAKIAogdm9pZCBzbmRfYWs0MTE0X3JlaW5pdChzdHJ1Y3QgYWs0MTE0ICpjaGlwKQogewotCWNoaXAtPmluaXQgPSAxOwotCW1iKCk7Ci0JZmx1c2hfZGVsYXllZF93b3JrKCZjaGlwLT53b3JrKTsKKwlpZiAoYXRvbWljX2luY19yZXR1cm4oJmNoaXAtPndxX3Byb2Nlc3NpbmcpID09IDEpCisJCWNhbmNlbF9kZWxheWVkX3dvcmtfc3luYygmY2hpcC0+d29yayk7CiAJYWs0MTE0X2luaXRfcmVncyhjaGlwKTsKIAkvKiBicmluZyB1cCBzdGF0aXN0aWNzIC8gZXZlbnQgcXVlaW5nICovCi0JY2hpcC0+aW5pdCA9IDA7Ci0JaWYgKGNoaXAtPmtjdGxzWzBdKQorCWlmIChhdG9taWNfZGVjX2FuZF90ZXN0KCZjaGlwLT53cV9wcm9jZXNzaW5nKSkKIAkJc2NoZWR1bGVfZGVsYXllZF93b3JrKCZjaGlwLT53b3JrLCBIWiAvIDEwKTsKIH0KIApAQCAtNjEyLDEwICs2MTAsMTAgQEAKIHsKIAlzdHJ1Y3QgYWs0MTE0ICpjaGlwID0gY29udGFpbmVyX29mKHdvcmssIHN0cnVjdCBhazQxMTQsIHdvcmsud29yayk7CiAKLQlpZiAoIWNoaXAtPmluaXQpCisJaWYgKGF0b21pY19pbmNfcmV0dXJuKCZjaGlwLT53cV9wcm9jZXNzaW5nKSA9PSAxKQogCQlzbmRfYWs0MTE0X2NoZWNrX3JhdGVfYW5kX2Vycm9ycyhjaGlwLCBjaGlwLT5jaGVja19mbGFncyk7Ci0KLQlzY2hlZHVsZV9kZWxheWVkX3dvcmsoJmNoaXAtPndvcmssIEhaIC8gMTApOworCWlmIChhdG9taWNfZGVjX2FuZF90ZXN0KCZjaGlwLT53cV9wcm9jZXNzaW5nKSkKKwkJc2NoZWR1bGVfZGVsYXllZF93b3JrKCZjaGlwLT53b3JrLCBIWiAvIDEwKTsKIH0KIAogRVhQT1JUX1NZTUJPTChzbmRfYWs0MTE0X2NyZWF0ZSk7CmRpZmYgLS1naXQgYS9zb3VuZC9zb2MvYWRpL2F4aS1pMnMuYyBiL3NvdW5kL3NvYy9hZGkvYXhpLWkycy5jCmluZGV4IDc3NTI4NjAuLjRjMjMzODEgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9hZGkvYXhpLWkycy5jCisrKyBiL3NvdW5kL3NvYy9hZGkvYXhpLWkycy5jCkBAIC0yNDAsNiArMjQwLDggQEAKIAlpZiAocmV0KQogCQlnb3RvIGVycl9jbGtfZGlzYWJsZTsKIAorCXJldHVybiAwOworCiBlcnJfY2xrX2Rpc2FibGU6CiAJY2xrX2Rpc2FibGVfdW5wcmVwYXJlKGkycy0+Y2xrKTsKIAlyZXR1cm4gcmV0OwpkaWZmIC0tZ2l0IGEvc291bmQvc29jL2F0bWVsL2F0bWVsX3NzY19kYWkuYyBiL3NvdW5kL3NvYy9hdG1lbC9hdG1lbF9zc2NfZGFpLmMKaW5kZXggOTlmZjM1ZS4uMzVlNDRlNCAxMDA2NDQKLS0tIGEvc291bmQvc29jL2F0bWVsL2F0bWVsX3NzY19kYWkuYworKysgYi9zb3VuZC9zb2MvYXRtZWwvYXRtZWxfc3NjX2RhaS5jCkBAIC0zNDgsNyArMzQ4LDYgQEAKIAlzdHJ1Y3QgYXRtZWxfcGNtX2RtYV9wYXJhbXMgKmRtYV9wYXJhbXM7CiAJaW50IGRpciwgY2hhbm5lbHMsIGJpdHM7CiAJdTMyIHRmbXIsIHJmbXIsIHRjbXIsIHJjbXI7Ci0JaW50IHN0YXJ0X2V2ZW50OwogCWludCByZXQ7CiAJaW50IGZzbGVuLCBmc2xlbl9leHQ7CiAKQEAgLTQ1NywxOSArNDU2LDEwIEBACiAJCSAqIFRoZSBTU0MgdHJhbnNtaXQgY2xvY2sgaXMgb2J0YWluZWQgZnJvbSB0aGUgQkNMSyBzaWduYWwgb24KIAkJICogb24gdGhlIFRLIGxpbmUsIGFuZCB0aGUgU1NDIHJlY2VpdmUgY2xvY2sgaXMKIAkJICogZ2VuZXJhdGVkIGZyb20gdGhlIHRyYW5zbWl0IGNsb2NrLgotCQkgKgotCQkgKiAgRm9yIHNpbmdsZSBjaGFubmVsIGRhdGEsIG9uZSBzYW1wbGUgaXMgdHJhbnNmZXJyZWQKLQkJICogb24gdGhlIGZhbGxpbmcgZWRnZSBvZiB0aGUgTFJDIGNsb2NrLgotCQkgKiBGb3IgdHdvIGNoYW5uZWwgZGF0YSwgb25lIHNhbXBsZSBpcwotCQkgKiB0cmFuc2ZlcnJlZCBvbiBib3RoIGVkZ2VzIG9mIHRoZSBMUkMgY2xvY2suCiAJCSAqLwotCQlzdGFydF9ldmVudCA9ICgoY2hhbm5lbHMgPT0gMSkKLQkJCQk/IFNTQ19TVEFSVF9GQUxMSU5HX1JGCi0JCQkJOiBTU0NfU1RBUlRfRURHRV9SRik7Ci0KIAkJcmNtciA9CSAgU1NDX0JGKFJDTVJfUEVSSU9ELCAwKQogCQkJfCBTU0NfQkYoUkNNUl9TVFRETFksIFNUQVJUX0RFTEFZKQotCQkJfCBTU0NfQkYoUkNNUl9TVEFSVCwgc3RhcnRfZXZlbnQpCisJCQl8IFNTQ19CRihSQ01SX1NUQVJULCBTU0NfU1RBUlRfRkFMTElOR19SRikKIAkJCXwgU1NDX0JGKFJDTVJfQ0tJLCBTU0NfQ0tJX1JJU0lORykKIAkJCXwgU1NDX0JGKFJDTVJfQ0tPLCBTU0NfQ0tPX05PTkUpCiAJCQl8IFNTQ19CRihSQ01SX0NLUywgc3NjLT5jbGtfZnJvbV9ya19waW4gPwpAQCAtNDc4LDE0ICs0NjgsMTQgQEAKIAkJcmZtciA9CSAgU1NDX0JGKFJGTVJfRlNFREdFLCBTU0NfRlNFREdFX1BPU0lUSVZFKQogCQkJfCBTU0NfQkYoUkZNUl9GU09TLCBTU0NfRlNPU19OT05FKQogCQkJfCBTU0NfQkYoUkZNUl9GU0xFTiwgMCkKLQkJCXwgU1NDX0JGKFJGTVJfREFUTkIsIDApCisJCQl8IFNTQ19CRihSRk1SX0RBVE5CLCAoY2hhbm5lbHMgLSAxKSkKIAkJCXwgU1NDX0JJVChSRk1SX01TQkYpCiAJCQl8IFNTQ19CRihSRk1SX0xPT1AsIDApCiAJCQl8IFNTQ19CRihSRk1SX0RBVExFTiwgKGJpdHMgLSAxKSk7CiAKIAkJdGNtciA9CSAgU1NDX0JGKFRDTVJfUEVSSU9ELCAwKQogCQkJfCBTU0NfQkYoVENNUl9TVFRETFksIFNUQVJUX0RFTEFZKQotCQkJfCBTU0NfQkYoVENNUl9TVEFSVCwgc3RhcnRfZXZlbnQpCisJCQl8IFNTQ19CRihUQ01SX1NUQVJULCBTU0NfU1RBUlRfRkFMTElOR19SRikKIAkJCXwgU1NDX0JGKFRDTVJfQ0tJLCBTU0NfQ0tJX0ZBTExJTkcpCiAJCQl8IFNTQ19CRihUQ01SX0NLTywgU1NDX0NLT19OT05FKQogCQkJfCBTU0NfQkYoVENNUl9DS1MsIHNzYy0+Y2xrX2Zyb21fcmtfcGluID8KQEAgLTQ5NSw3ICs0ODUsNyBAQAogCQkJfCBTU0NfQkYoVEZNUl9GU0RFTiwgMCkKIAkJCXwgU1NDX0JGKFRGTVJfRlNPUywgU1NDX0ZTT1NfTk9ORSkKIAkJCXwgU1NDX0JGKFRGTVJfRlNMRU4sIDApCi0JCQl8IFNTQ19CRihURk1SX0RBVE5CLCAwKQorCQkJfCBTU0NfQkYoVEZNUl9EQVROQiwgKGNoYW5uZWxzIC0gMSkpCiAJCQl8IFNTQ19CSVQoVEZNUl9NU0JGKQogCQkJfCBTU0NfQkYoVEZNUl9EQVRERUYsIDApCiAJCQl8IFNTQ19CRihURk1SX0RBVExFTiwgKGJpdHMgLSAxKSk7CkBAIC01MTIsNyArNTAyLDcgQEAKIAkJcmNtciA9CSAgU1NDX0JGKFJDTVJfUEVSSU9ELCBzc2NfcC0+cmNtcl9wZXJpb2QpCiAJCQl8IFNTQ19CRihSQ01SX1NUVERMWSwgMSkKIAkJCXwgU1NDX0JGKFJDTVJfU1RBUlQsIFNTQ19TVEFSVF9SSVNJTkdfUkYpCi0JCQl8IFNTQ19CRihSQ01SX0NLSSwgU1NDX0NLSV9SSVNJTkcpCisJCQl8IFNTQ19CRihSQ01SX0NLSSwgU1NDX0NLSV9GQUxMSU5HKQogCQkJfCBTU0NfQkYoUkNNUl9DS08sIFNTQ19DS09fTk9ORSkKIAkJCXwgU1NDX0JGKFJDTVJfQ0tTLCBTU0NfQ0tTX0RJVik7CiAKQEAgLTUyNyw3ICs1MTcsNyBAQAogCQl0Y21yID0JICBTU0NfQkYoVENNUl9QRVJJT0QsIHNzY19wLT50Y21yX3BlcmlvZCkKIAkJCXwgU1NDX0JGKFRDTVJfU1RURExZLCAxKQogCQkJfCBTU0NfQkYoVENNUl9TVEFSVCwgU1NDX1NUQVJUX1JJU0lOR19SRikKLQkJCXwgU1NDX0JGKFRDTVJfQ0tJLCBTU0NfQ0tJX1JJU0lORykKKwkJCXwgU1NDX0JGKFRDTVJfQ0tJLCBTU0NfQ0tJX0ZBTExJTkcpCiAJCQl8IFNTQ19CRihUQ01SX0NLTywgU1NDX0NLT19DT05USU5VT1VTKQogCQkJfCBTU0NfQkYoVENNUl9DS1MsIFNTQ19DS1NfRElWKTsKIApAQCAtNTU2LDcgKzU0Niw3IEBACiAJCXJjbXIgPQkgIFNTQ19CRihSQ01SX1BFUklPRCwgMCkKIAkJCXwgU1NDX0JGKFJDTVJfU1RURExZLCBTVEFSVF9ERUxBWSkKIAkJCXwgU1NDX0JGKFJDTVJfU1RBUlQsIFNTQ19TVEFSVF9SSVNJTkdfUkYpCi0JCQl8IFNTQ19CRihSQ01SX0NLSSwgU1NDX0NLSV9SSVNJTkcpCisJCQl8IFNTQ19CRihSQ01SX0NLSSwgU1NDX0NLSV9GQUxMSU5HKQogCQkJfCBTU0NfQkYoUkNNUl9DS08sIFNTQ19DS09fTk9ORSkKIAkJCXwgU1NDX0JGKFJDTVJfQ0tTLCBzc2MtPmNsa19mcm9tX3JrX3BpbiA/CiAJCQkJCSAgIFNTQ19DS1NfUElOIDogU1NDX0NLU19DTE9DSyk7CmRpZmYgLS1naXQgYS9zb3VuZC9zb2MvY29kZWNzL3BjbTUxMnguYyBiL3NvdW5kL3NvYy9jb2RlY3MvcGNtNTEyeC5jCmluZGV4IGU1ZjJmYjguLjMwYzY3M2MgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9jb2RlY3MvcGNtNTEyeC5jCisrKyBiL3NvdW5kL3NvYy9jb2RlY3MvcGNtNTEyeC5jCkBAIC0xODgsOCArMTg4LDggQEAKIHN0YXRpYyBjb25zdCBjaGFyICogY29uc3QgcGNtNTEyeF9kc3BfcHJvZ3JhbV90ZXh0c1tdID0gewogCSJGSVIgaW50ZXJwb2xhdGlvbiB3aXRoIGRlLWVtcGhhc2lzIiwKIAkiTG93IGxhdGVuY3kgSUlSIHdpdGggZGUtZW1waGFzaXMiLAotCSJGaXhlZCBwcm9jZXNzIGZsb3ciLAogCSJIaWdoIGF0dGVudWF0aW9uIHdpdGggZGUtZW1waGFzaXMiLAorCSJGaXhlZCBwcm9jZXNzIGZsb3ciLAogCSJSaW5naW5nLWxlc3MgbG93IGxhdGVuY3kgRklSIiwKIH07CiAKZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9jb2RlY3MvcnQyODYuYyBiL3NvdW5kL3NvYy9jb2RlY3MvcnQyODYuYwppbmRleCAyY2Q0ZmU0Li4xZDFjN2Y4IDEwMDY0NAotLS0gYS9zb3VuZC9zb2MvY29kZWNzL3J0Mjg2LmMKKysrIGIvc291bmQvc29jL2NvZGVjcy9ydDI4Ni5jCkBAIC04NjEsMTAgKzg2MSw4IEBACiAJCVJUMjg2X0kyU19DVFJMMSwgMHgwMDE4LCBkX2xlbl9jb2RlIDw8IDMpOwogCWRldl9kYmcoY29kZWMtPmRldiwgImZvcm1hdCB2YWwgPSAweCV4XG4iLCB2YWwpOwogCi0JaWYgKHN1YnN0cmVhbS0+c3RyZWFtID09IFNORFJWX1BDTV9TVFJFQU1fUExBWUJBQ0spCi0JCXNuZF9zb2NfdXBkYXRlX2JpdHMoY29kZWMsIFJUMjg2X0RBQ19GT1JNQVQsIDB4NDA3ZiwgdmFsKTsKLQllbHNlCi0JCXNuZF9zb2NfdXBkYXRlX2JpdHMoY29kZWMsIFJUMjg2X0FEQ19GT1JNQVQsIDB4NDA3ZiwgdmFsKTsKKwlzbmRfc29jX3VwZGF0ZV9iaXRzKGNvZGVjLCBSVDI4Nl9EQUNfRk9STUFULCAweDQwN2YsIHZhbCk7CisJc25kX3NvY191cGRhdGVfYml0cyhjb2RlYywgUlQyODZfQURDX0ZPUk1BVCwgMHg0MDdmLCB2YWwpOwogCiAJcmV0dXJuIDA7CiB9CmRpZmYgLS1naXQgYS9zb3VuZC9zb2MvY29kZWNzL3J0NTY0MC5jIGIvc291bmQvc29jL2NvZGVjcy9ydDU2NDAuYwppbmRleCBjM2YyZGVjLi4xZmY3MjZjIDEwMDY0NAotLS0gYS9zb3VuZC9zb2MvY29kZWNzL3J0NTY0MC5jCisrKyBiL3NvdW5kL3NvYy9jb2RlY3MvcnQ1NjQwLmMKQEAgLTIxMjQsNiArMjEyNCw3IEBACiBzdGF0aWMgc3RydWN0IGFjcGlfZGV2aWNlX2lkIHJ0NTY0MF9hY3BpX21hdGNoW10gPSB7CiAJeyAiSU5UMzNDQSIsIDAgfSwKIAl7ICIxMEVDNTY0MCIsIDAgfSwKKwl7ICIxMEVDNTY0MiIsIDAgfSwKIAl7IH0sCiB9OwogTU9EVUxFX0RFVklDRV9UQUJMRShhY3BpLCBydDU2NDBfYWNwaV9tYXRjaCk7CmRpZmYgLS1naXQgYS9zb3VuZC9zb2MvY29kZWNzL3J0NTY3Ny5jIGIvc291bmQvc29jL2NvZGVjcy9ydDU2NzcuYwppbmRleCBjMGZiZTE4Li45MThhZGE5IDEwMDY0NAotLS0gYS9zb3VuZC9zb2MvY29kZWNzL3J0NTY3Ny5jCisrKyBiL3NvdW5kL3NvYy9jb2RlY3MvcnQ1Njc3LmMKQEAgLTIwODMsMTAgKzIwODMsMTQgQEAKIAlzdHJ1Y3QgcnQ1Njc3X3ByaXYgKnJ0NTY3NyA9IHNuZF9zb2NfY29kZWNfZ2V0X2RydmRhdGEoY29kZWMpOwogCiAJc3dpdGNoIChldmVudCkgewotCWNhc2UgU05EX1NPQ19EQVBNX1BPU1RfUE1VOgorCWNhc2UgU05EX1NPQ19EQVBNX1BSRV9QTVU6CiAJCXJlZ21hcF91cGRhdGVfYml0cyhydDU2NzctPnJlZ21hcCwgUlQ1Njc3X1BMTDFfQ1RSTDIsIDB4MiwgMHgyKTsKKwkJYnJlYWs7CisKKwljYXNlIFNORF9TT0NfREFQTV9QT1NUX1BNVToKIAkJcmVnbWFwX3VwZGF0ZV9iaXRzKHJ0NTY3Ny0+cmVnbWFwLCBSVDU2NzdfUExMMV9DVFJMMiwgMHgyLCAweDApOwogCQlicmVhazsKKwogCWRlZmF1bHQ6CiAJCXJldHVybiAwOwogCX0KQEAgLTIxMDEsMTAgKzIxMDUsMTQgQEAKIAlzdHJ1Y3QgcnQ1Njc3X3ByaXYgKnJ0NTY3NyA9IHNuZF9zb2NfY29kZWNfZ2V0X2RydmRhdGEoY29kZWMpOwogCiAJc3dpdGNoIChldmVudCkgewotCWNhc2UgU05EX1NPQ19EQVBNX1BPU1RfUE1VOgorCWNhc2UgU05EX1NPQ19EQVBNX1BSRV9QTVU6CiAJCXJlZ21hcF91cGRhdGVfYml0cyhydDU2NzctPnJlZ21hcCwgUlQ1Njc3X1BMTDJfQ1RSTDIsIDB4MiwgMHgyKTsKKwkJYnJlYWs7CisKKwljYXNlIFNORF9TT0NfREFQTV9QT1NUX1BNVToKIAkJcmVnbWFwX3VwZGF0ZV9iaXRzKHJ0NTY3Ny0+cmVnbWFwLCBSVDU2NzdfUExMMl9DVFJMMiwgMHgyLCAweDApOwogCQlicmVhazsKKwogCWRlZmF1bHQ6CiAJCXJldHVybiAwOwogCX0KQEAgLTIyMTIsOSArMjIyMCwxMSBAQAogCiBzdGF0aWMgY29uc3Qgc3RydWN0IHNuZF9zb2NfZGFwbV93aWRnZXQgcnQ1Njc3X2RhcG1fd2lkZ2V0c1tdID0gewogCVNORF9TT0NfREFQTV9TVVBQTFkoIlBMTDEiLCBSVDU2NzdfUFdSX0FOTEcyLCBSVDU2NzdfUFdSX1BMTDFfQklULAotCQkwLCBydDU2Nzdfc2V0X3BsbDFfZXZlbnQsIFNORF9TT0NfREFQTV9QT1NUX1BNVSksCisJCTAsIHJ0NTY3N19zZXRfcGxsMV9ldmVudCwgU05EX1NPQ19EQVBNX1BSRV9QTVUgfAorCQlTTkRfU09DX0RBUE1fUE9TVF9QTVUpLAogCVNORF9TT0NfREFQTV9TVVBQTFkoIlBMTDIiLCBSVDU2NzdfUFdSX0FOTEcyLCBSVDU2NzdfUFdSX1BMTDJfQklULAotCQkwLCBydDU2Nzdfc2V0X3BsbDJfZXZlbnQsIFNORF9TT0NfREFQTV9QT1NUX1BNVSksCisJCTAsIHJ0NTY3N19zZXRfcGxsMl9ldmVudCwgU05EX1NPQ19EQVBNX1BSRV9QTVUgfAorCQlTTkRfU09DX0RBUE1fUE9TVF9QTVUpLAogCiAJLyogSW5wdXQgU2lkZSAqLwogCS8qIG1pY2JpYXMgKi8KZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9jb2RlY3Mvc2d0bDUwMDAuYyBiL3NvdW5kL3NvYy9jb2RlY3Mvc2d0bDUwMDAuYwppbmRleCAyOWNmN2NlLi5hYTk4YmUzIDEwMDY0NAotLS0gYS9zb3VuZC9zb2MvY29kZWNzL3NndGw1MDAwLmMKKysrIGIvc291bmQvc29jL2NvZGVjcy9zZ3RsNTAwMC5jCkBAIC00ODMsMjEgKzQ4MywyMSBAQAogCS8qIHNldHRpbmcgaTJzIGRhdGEgZm9ybWF0ICovCiAJc3dpdGNoIChmbXQgJiBTTkRfU09DX0RBSUZNVF9GT1JNQVRfTUFTSykgewogCWNhc2UgU05EX1NPQ19EQUlGTVRfRFNQX0E6Ci0JCWkyc2N0bCB8PSBTR1RMNTAwMF9JMlNfTU9ERV9QQ007CisJCWkyc2N0bCB8PSBTR1RMNTAwMF9JMlNfTU9ERV9QQ00gPDwgU0dUTDUwMDBfSTJTX01PREVfU0hJRlQ7CiAJCWJyZWFrOwogCWNhc2UgU05EX1NPQ19EQUlGTVRfRFNQX0I6Ci0JCWkyc2N0bCB8PSBTR1RMNTAwMF9JMlNfTU9ERV9QQ007CisJCWkyc2N0bCB8PSBTR1RMNTAwMF9JMlNfTU9ERV9QQ00gPDwgU0dUTDUwMDBfSTJTX01PREVfU0hJRlQ7CiAJCWkyc2N0bCB8PSBTR1RMNTAwMF9JMlNfTFJBTElHTjsKIAkJYnJlYWs7CiAJY2FzZSBTTkRfU09DX0RBSUZNVF9JMlM6Ci0JCWkyc2N0bCB8PSBTR1RMNTAwMF9JMlNfTU9ERV9JMlNfTEo7CisJCWkyc2N0bCB8PSBTR1RMNTAwMF9JMlNfTU9ERV9JMlNfTEogPDwgU0dUTDUwMDBfSTJTX01PREVfU0hJRlQ7CiAJCWJyZWFrOwogCWNhc2UgU05EX1NPQ19EQUlGTVRfUklHSFRfSjoKLQkJaTJzY3RsIHw9IFNHVEw1MDAwX0kyU19NT0RFX1JKOworCQlpMnNjdGwgfD0gU0dUTDUwMDBfSTJTX01PREVfUkogPDwgU0dUTDUwMDBfSTJTX01PREVfU0hJRlQ7CiAJCWkyc2N0bCB8PSBTR1RMNTAwMF9JMlNfTFJQT0w7CiAJCWJyZWFrOwogCWNhc2UgU05EX1NPQ19EQUlGTVRfTEVGVF9KOgotCQlpMnNjdGwgfD0gU0dUTDUwMDBfSTJTX01PREVfSTJTX0xKOworCQlpMnNjdGwgfD0gU0dUTDUwMDBfSTJTX01PREVfSTJTX0xKIDw8IFNHVEw1MDAwX0kyU19NT0RFX1NISUZUOwogCQlpMnNjdGwgfD0gU0dUTDUwMDBfSTJTX0xSQUxJR047CiAJCWJyZWFrOwogCWRlZmF1bHQ6CkBAIC0xNDYyLDYgKzE0NjIsOSBAQAogCWlmIChyZXQpCiAJCXJldHVybiByZXQ7CiAKKwkvKiBOZWVkIDggY2xvY2tzIGJlZm9yZSBJMkMgYWNjZXNzZXMgKi8KKwl1ZGVsYXkoMSk7CisKIAkvKiByZWFkIGNoaXAgaW5mb3JtYXRpb24gKi8KIAlyZXQgPSByZWdtYXBfcmVhZChzZ3RsNTAwMC0+cmVnbWFwLCBTR1RMNTAwMF9DSElQX0lELCAmcmVnKTsKIAlpZiAocmV0KQpkaWZmIC0tZ2l0IGEvc291bmQvc29jL2NvZGVjcy90bHYzMjBhaWMzeC5jIGIvc291bmQvc29jL2NvZGVjcy90bHYzMjBhaWMzeC5jCmluZGV4IGI3ZWJjZTAuLmRkMjIyYjEgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9jb2RlY3MvdGx2MzIwYWljM3guYworKysgYi9zb3VuZC9zb2MvY29kZWNzL3RsdjMyMGFpYzN4LmMKQEAgLTEwNDYsNyArMTA0Niw3IEBACiAJCWRlbGF5ICs9IGFpYzN4LT50ZG1fZGVsYXk7CiAKIAkvKiBDb25maWd1cmUgZGF0YSBkZWxheSAqLwotCXNuZF9zb2Nfd3JpdGUoY29kZWMsIEFJQzNYX0FTRF9JTlRGX0NUUkxDLCBhaWMzeC0+dGRtX2RlbGF5KTsKKwlzbmRfc29jX3dyaXRlKGNvZGVjLCBBSUMzWF9BU0RfSU5URl9DVFJMQywgZGVsYXkpOwogCiAJcmV0dXJuIDA7CiB9CmRpZmYgLS1naXQgYS9zb3VuZC9zb2MvY29kZWNzL3RzM2EyMjdlLmMgYi9zb3VuZC9zb2MvY29kZWNzL3RzM2EyMjdlLmMKaW5kZXggMWQxMjA1Ny4uOWYyZGNlZCAxMDA2NDQKLS0tIGEvc291bmQvc29jL2NvZGVjcy90czNhMjI3ZS5jCisrKyBiL3NvdW5kL3NvYy9jb2RlY3MvdHMzYTIyN2UuYwpAQCAtMjU0LDYgKzI1NCw3IEBACiAJc3RydWN0IHRzM2EyMjdlICp0czNhMjI3ZTsKIAlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmaTJjLT5kZXY7CiAJaW50IHJldDsKKwl1bnNpZ25lZCBpbnQgYWNjX3JlZzsKIAogCXRzM2EyMjdlID0gZGV2bV9remFsbG9jKCZpMmMtPmRldiwgc2l6ZW9mKCp0czNhMjI3ZSksIEdGUF9LRVJORUwpOwogCWlmICh0czNhMjI3ZSA9PSBOVUxMKQpAQCAtMjgzLDYgKzI4NCwxMSBAQAogCQkJICAgSU5UQl9ESVNBQkxFIHwgQURDX0NPTVBMRVRFX0lOVF9ESVNBQkxFLAogCQkJICAgQURDX0NPTVBMRVRFX0lOVF9ESVNBQkxFKTsKIAorCS8qIFJlYWQgamFjayBzdGF0dXMgYmVjYXVzZSBjaGlwIG1pZ2h0IG5vdCB0cmlnZ2VyIGludGVycnVwdCBhdCBib290LiAqLworCXJlZ21hcF9yZWFkKHRzM2EyMjdlLT5yZWdtYXAsIFRTM0EyMjdFX1JFR19BQ0NFU1NPUllfU1RBVFVTLCAmYWNjX3JlZyk7CisJdHMzYTIyN2VfbmV3X2phY2tfc3RhdGUodHMzYTIyN2UsIGFjY19yZWcpOworCXRzM2EyMjdlX2phY2tfcmVwb3J0KHRzM2EyMjdlKTsKKwogCXJldHVybiAwOwogfQogCmRpZmYgLS1naXQgYS9zb3VuZC9zb2MvY29kZWNzL3dtODczMS5jIGIvc291bmQvc29jL2NvZGVjcy93bTg3MzEuYwppbmRleCBiOTIxMWI0Li5iMTE1ZWQ4IDEwMDY0NAotLS0gYS9zb3VuZC9zb2MvY29kZWNzL3dtODczMS5jCisrKyBiL3NvdW5kL3NvYy9jb2RlY3Mvd204NzMxLmMKQEAgLTcxNyw2ICs3MTcsOCBAQAogCWlmICh3bTg3MzEgPT0gTlVMTCkKIAkJcmV0dXJuIC1FTk9NRU07CiAKKwltdXRleF9pbml0KCZ3bTg3MzEtPmxvY2spOworCiAJd204NzMxLT5yZWdtYXAgPSBkZXZtX3JlZ21hcF9pbml0X2kyYyhpMmMsICZ3bTg3MzFfcmVnbWFwKTsKIAlpZiAoSVNfRVJSKHdtODczMS0+cmVnbWFwKSkgewogCQlyZXQgPSBQVFJfRVJSKHdtODczMS0+cmVnbWFwKTsKZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9jb2RlY3Mvd204OTA0LmMgYi9zb3VuZC9zb2MvY29kZWNzL3dtODkwNC5jCmluZGV4IDRkMmQyYjEuLjc1Yjg3YzUgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9jb2RlY3Mvd204OTA0LmMKKysrIGIvc291bmQvc29jL2NvZGVjcy93bTg5MDQuYwpAQCAtMTA3NiwxMCArMTA3NiwxMyBAQAogCXsgIlJpZ2h0IENhcHR1cmUgUEdBIiwgTlVMTCwgIlJpZ2h0IENhcHR1cmUgTXV4IiB9LAogCXsgIlJpZ2h0IENhcHR1cmUgUEdBIiwgTlVMTCwgIlJpZ2h0IENhcHR1cmUgSW52ZXJ0aW5nIE11eCIgfSwKIAotCXsgIkFJRk9VVEwiLCAiTGVmdCIsICAiQURDTCIgfSwKLQl7ICJBSUZPVVRMIiwgIlJpZ2h0IiwgIkFEQ1IiIH0sCi0JeyAiQUlGT1VUUiIsICJMZWZ0IiwgICJBRENMIiB9LAotCXsgIkFJRk9VVFIiLCAiUmlnaHQiLCAiQURDUiIgfSwKKwl7ICJBSUZPVVRMIE11eCIsICJMZWZ0IiwgIkFEQ0wiIH0sCisJeyAiQUlGT1VUTCBNdXgiLCAiUmlnaHQiLCAiQURDUiIgfSwKKwl7ICJBSUZPVVRSIE11eCIsICJMZWZ0IiwgIkFEQ0wiIH0sCisJeyAiQUlGT1VUUiBNdXgiLCAiUmlnaHQiLCAiQURDUiIgfSwKKworCXsgIkFJRk9VVEwiLCBOVUxMLCAiQUlGT1VUTCBNdXgiIH0sCisJeyAiQUlGT1VUUiIsIE5VTEwsICJBSUZPVVRSIE11eCIgfSwKIAogCXsgIkFEQ0wiLCBOVUxMLCAiQ0xLX0RTUCIgfSwKIAl7ICJBRENMIiwgTlVMTCwgIkxlZnQgQ2FwdHVyZSBQR0EiIH0sCkBAIC0xMDg5LDEyICsxMDkyLDE2IEBACiB9OwogCiBzdGF0aWMgY29uc3Qgc3RydWN0IHNuZF9zb2NfZGFwbV9yb3V0ZSBkYWNfaW50ZXJjb25bXSA9IHsKLQl7ICJEQUNMIiwgIlJpZ2h0IiwgIkFJRklOUiIgfSwKLQl7ICJEQUNMIiwgIkxlZnQiLCAgIkFJRklOTCIgfSwKKwl7ICJEQUNMIE11eCIsICJMZWZ0IiwgIkFJRklOTCIgfSwKKwl7ICJEQUNMIE11eCIsICJSaWdodCIsICJBSUZJTlIiIH0sCisKKwl7ICJEQUNSIE11eCIsICJMZWZ0IiwgIkFJRklOTCIgfSwKKwl7ICJEQUNSIE11eCIsICJSaWdodCIsICJBSUZJTlIiIH0sCisKKwl7ICJEQUNMIiwgTlVMTCwgIkRBQ0wgTXV4IiB9LAogCXsgIkRBQ0wiLCBOVUxMLCAiQ0xLX0RTUCIgfSwKIAotCXsgIkRBQ1IiLCAiUmlnaHQiLCAiQUlGSU5SIiB9LAotCXsgIkRBQ1IiLCAiTGVmdCIsICAiQUlGSU5MIiB9LAorCXsgIkRBQ1IiLCBOVUxMLCAiREFDUiBNdXgiIH0sCiAJeyAiREFDUiIsIE5VTEwsICJDTEtfRFNQIiB9LAogCiAJeyAiQ2hhcmdlIHB1bXAiLCBOVUxMLCAiU1lTQ0xLIiB9LApkaWZmIC0tZ2l0IGEvc291bmQvc29jL2NvZGVjcy93bTg5NjAuYyBiL3NvdW5kL3NvYy9jb2RlY3Mvd204OTYwLmMKaW5kZXggMDMxYTFhZS4uYTk2ZWI0OSAxMDA2NDQKLS0tIGEvc291bmQvc29jL2NvZGVjcy93bTg5NjAuYworKysgYi9zb3VuZC9zb2MvY29kZWNzL3dtODk2MC5jCkBAIC01NTYsNyArNTU2LDcgQEAKIAl7IDIyMDUwLCAyIH0sCiAJeyAyNDAwMCwgMiB9LAogCXsgMTYwMDAsIDMgfSwKLQl7IDExMjUwLCA0IH0sCisJeyAxMTAyNSwgNCB9LAogCXsgMTIwMDAsIDQgfSwKIAl7ICA4MDAwLCA1IH0sCiB9OwpkaWZmIC0tZ2l0IGEvc291bmQvc29jL2NvZGVjcy93bTk3MDUuYyBiL3NvdW5kL3NvYy9jb2RlY3Mvd205NzA1LmMKaW5kZXggM2VkZGIxOC4uNWNjNDU3ZSAxMDA2NDQKLS0tIGEvc291bmQvc29jL2NvZGVjcy93bTk3MDUuYworKysgYi9zb3VuZC9zb2MvY29kZWNzL3dtOTcwNS5jCkBAIC0zNDQsMjMgKzM0NCwyNyBAQAogCXN0cnVjdCBzbmRfYWM5NyAqYWM5NzsKIAlpbnQgcmV0ID0gMDsKIAotCWFjOTcgPSBzbmRfc29jX25ld19hYzk3X2NvZGVjKGNvZGVjKTsKKwlhYzk3ID0gc25kX3NvY19hbGxvY19hYzk3X2NvZGVjKGNvZGVjKTsKIAlpZiAoSVNfRVJSKGFjOTcpKSB7CiAJCXJldCA9IFBUUl9FUlIoYWM5Nyk7CiAJCWRldl9lcnIoY29kZWMtPmRldiwgIkZhaWxlZCB0byByZWdpc3RlciBBQzk3IGNvZGVjXG4iKTsKIAkJcmV0dXJuIHJldDsKIAl9CiAKLQlzbmRfc29jX2NvZGVjX3NldF9kcnZkYXRhKGNvZGVjLCBhYzk3KTsKLQogCXJldCA9IHdtOTcwNV9yZXNldChjb2RlYyk7CiAJaWYgKHJldCkKLQkJZ290byByZXNldF9lcnI7CisJCWdvdG8gZXJyX3B1dF9kZXZpY2U7CisKKwlyZXQgPSBkZXZpY2VfYWRkKCZhYzk3LT5kZXYpOworCWlmIChyZXQpCisJCWdvdG8gZXJyX3B1dF9kZXZpY2U7CisKKwlzbmRfc29jX2NvZGVjX3NldF9kcnZkYXRhKGNvZGVjLCBhYzk3KTsKIAogCXJldHVybiAwOwogCi1yZXNldF9lcnI6Ci0Jc25kX3NvY19mcmVlX2FjOTdfY29kZWMoYWM5Nyk7CitlcnJfcHV0X2RldmljZToKKwlwdXRfZGV2aWNlKCZhYzk3LT5kZXYpOwogCXJldHVybiByZXQ7CiB9CiAKZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9jb2RlY3Mvd205NzEyLmMgYi9zb3VuZC9zb2MvY29kZWNzL3dtOTcxMi5jCmluZGV4IGUwNDY0M2QuLjk1MTc1NzEgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9jb2RlY3Mvd205NzEyLmMKKysrIGIvc291bmQvc29jL2NvZGVjcy93bTk3MTIuYwpAQCAtNjY2LDcgKzY2Niw3IEBACiAJc3RydWN0IHdtOTcxMl9wcml2ICp3bTk3MTIgPSBzbmRfc29jX2NvZGVjX2dldF9kcnZkYXRhKGNvZGVjKTsKIAlpbnQgcmV0ID0gMDsKIAotCXdtOTcxMi0+YWM5NyA9IHNuZF9zb2NfbmV3X2FjOTdfY29kZWMoY29kZWMpOworCXdtOTcxMi0+YWM5NyA9IHNuZF9zb2NfYWxsb2NfYWM5N19jb2RlYyhjb2RlYyk7CiAJaWYgKElTX0VSUih3bTk3MTItPmFjOTcpKSB7CiAJCXJldCA9IFBUUl9FUlIod205NzEyLT5hYzk3KTsKIAkJZGV2X2Vycihjb2RlYy0+ZGV2LCAiRmFpbGVkIHRvIHJlZ2lzdGVyIEFDOTcgY29kZWM6ICVkXG4iLCByZXQpOwpAQCAtNjc1LDE1ICs2NzUsMTkgQEAKIAogCXJldCA9IHdtOTcxMl9yZXNldChjb2RlYywgMCk7CiAJaWYgKHJldCA8IDApCi0JCWdvdG8gcmVzZXRfZXJyOworCQlnb3RvIGVycl9wdXRfZGV2aWNlOworCisJcmV0ID0gZGV2aWNlX2FkZCgmd205NzEyLT5hYzk3LT5kZXYpOworCWlmIChyZXQpCisJCWdvdG8gZXJyX3B1dF9kZXZpY2U7CiAKIAkvKiBzZXQgYWxjIG11eCB0byBub25lICovCiAJYWM5N193cml0ZShjb2RlYywgQUM5N19WSURFTywgYWM5N19yZWFkKGNvZGVjLCBBQzk3X1ZJREVPKSB8IDB4MzAwMCk7CiAKIAlyZXR1cm4gMDsKIAotcmVzZXRfZXJyOgotCXNuZF9zb2NfZnJlZV9hYzk3X2NvZGVjKHdtOTcxMi0+YWM5Nyk7CitlcnJfcHV0X2RldmljZToKKwlwdXRfZGV2aWNlKCZ3bTk3MTItPmFjOTctPmRldik7CiAJcmV0dXJuIHJldDsKIH0KIApkaWZmIC0tZ2l0IGEvc291bmQvc29jL2NvZGVjcy93bTk3MTMuYyBiL3NvdW5kL3NvYy9jb2RlY3Mvd205NzEzLmMKaW5kZXggNzFiOWQ1Yi4uNmFiMTEyMiAxMDA2NDQKLS0tIGEvc291bmQvc29jL2NvZGVjcy93bTk3MTMuYworKysgYi9zb3VuZC9zb2MvY29kZWNzL3dtOTcxMy5jCkBAIC0xMjI1LDcgKzEyMjUsNyBAQAogCXN0cnVjdCB3bTk3MTNfcHJpdiAqd205NzEzID0gc25kX3NvY19jb2RlY19nZXRfZHJ2ZGF0YShjb2RlYyk7CiAJaW50IHJldCA9IDAsIHJlZzsKIAotCXdtOTcxMy0+YWM5NyA9IHNuZF9zb2NfbmV3X2FjOTdfY29kZWMoY29kZWMpOworCXdtOTcxMy0+YWM5NyA9IHNuZF9zb2NfYWxsb2NfYWM5N19jb2RlYyhjb2RlYyk7CiAJaWYgKElTX0VSUih3bTk3MTMtPmFjOTcpKQogCQlyZXR1cm4gUFRSX0VSUih3bTk3MTMtPmFjOTcpOwogCkBAIC0xMjM0LDcgKzEyMzQsMTEgQEAKIAl3bTk3MTNfcmVzZXQoY29kZWMsIDApOwogCXJldCA9IHdtOTcxM19yZXNldChjb2RlYywgMSk7CiAJaWYgKHJldCA8IDApCi0JCWdvdG8gcmVzZXRfZXJyOworCQlnb3RvIGVycl9wdXRfZGV2aWNlOworCisJcmV0ID0gZGV2aWNlX2FkZCgmd205NzEzLT5hYzk3LT5kZXYpOworCWlmIChyZXQpCisJCWdvdG8gZXJyX3B1dF9kZXZpY2U7CiAKIAkvKiB1bm11dGUgdGhlIGFkYyAtIG1vdmUgdG8ga2NvbnRyb2wgKi8KIAlyZWcgPSBhYzk3X3JlYWQoY29kZWMsIEFDOTdfQ0QpICYgMHg3ZmZmOwpAQCAtMTI0Miw4ICsxMjQ2LDggQEAKIAogCXJldHVybiAwOwogCi1yZXNldF9lcnI6Ci0Jc25kX3NvY19mcmVlX2FjOTdfY29kZWMod205NzEzLT5hYzk3KTsKK2Vycl9wdXRfZGV2aWNlOgorCXB1dF9kZXZpY2UoJndtOTcxMy0+YWM5Ny0+ZGV2KTsKIAlyZXR1cm4gcmV0OwogfQogCmRpZmYgLS1naXQgYS9zb3VuZC9zb2MvZnNsL2ZzbF9lc2FpLmggYi9zb3VuZC9zb2MvZnNsL2ZzbF9lc2FpLmgKaW5kZXggOTFhNTUwZi4uNWU3OTNiYiAxMDA2NDQKLS0tIGEvc291bmQvc29jL2ZzbC9mc2xfZXNhaS5oCisrKyBiL3NvdW5kL3NvYy9mc2wvZnNsX2VzYWkuaApAQCAtMzAyLDcgKzMwMiw3IEBACiAjZGVmaW5lIEVTQUlfeENDUl94RlBfTUFTSwkoKCgxIDw8IEVTQUlfeENDUl94RlBfV0lEVEgpIC0gMSkgPDwgRVNBSV94Q0NSX3hGUF9TSElGVCkKICNkZWZpbmUgRVNBSV94Q0NSX3hGUCh2KQkoKCgodikgLSAxKSA8PCBFU0FJX3hDQ1JfeEZQX1NISUZUKSAmIEVTQUlfeENDUl94RlBfTUFTSykKICNkZWZpbmUgRVNBSV94Q0NSX3hEQ19TSElGVCAgICAgOQotI2RlZmluZSBFU0FJX3hDQ1JfeERDX1dJRFRICTQKKyNkZWZpbmUgRVNBSV94Q0NSX3hEQ19XSURUSAk1CiAjZGVmaW5lIEVTQUlfeENDUl94RENfTUFTSwkoKCgxIDw8IEVTQUlfeENDUl94RENfV0lEVEgpIC0gMSkgPDwgRVNBSV94Q0NSX3hEQ19TSElGVCkKICNkZWZpbmUgRVNBSV94Q0NSX3hEQyh2KQkoKCgodikgLSAxKSA8PCBFU0FJX3hDQ1JfeERDX1NISUZUKSAmIEVTQUlfeENDUl94RENfTUFTSykKICNkZWZpbmUgRVNBSV94Q0NSX3hQU1JfU0hJRlQJOApkaWZmIC0tZ2l0IGEvc291bmQvc29jL2ZzbC9mc2xfc3NpLmMgYi9zb3VuZC9zb2MvZnNsL2ZzbF9zc2kuYwppbmRleCBhNjVmMTdkLi4wNTk0OTZlIDEwMDY0NAotLS0gYS9zb3VuZC9zb2MvZnNsL2ZzbF9zc2kuYworKysgYi9zb3VuZC9zb2MvZnNsL2ZzbF9zc2kuYwpAQCAtMTM2Miw5ICsxMzYyLDkgQEAKIAl9CiAKIAlzc2lfcHJpdmF0ZS0+aXJxID0gcGxhdGZvcm1fZ2V0X2lycShwZGV2LCAwKTsKLQlpZiAoIXNzaV9wcml2YXRlLT5pcnEpIHsKKwlpZiAoc3NpX3ByaXZhdGUtPmlycSA8IDApIHsKIAkJZGV2X2VycigmcGRldi0+ZGV2LCAibm8gaXJxIGZvciBub2RlICVzXG4iLCBucC0+ZnVsbF9uYW1lKTsKLQkJcmV0dXJuIC1FTlhJTzsKKwkJcmV0dXJuIHNzaV9wcml2YXRlLT5pcnE7CiAJfQogCiAJLyogQXJlIHRoZSBSWCBhbmQgdGhlIFRYIGNsb2NrcyBsb2NrZWQ/ICovCmRpZmYgLS1naXQgYS9zb3VuZC9zb2MvZnNsL2lteC13bTg5NjIuYyBiL3NvdW5kL3NvYy9mc2wvaW14LXdtODk2Mi5jCmluZGV4IDRjYWFjYjAuLmNkMTQ2ZDQgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9mc2wvaW14LXdtODk2Mi5jCisrKyBiL3NvdW5kL3NvYy9mc2wvaW14LXdtODk2Mi5jCkBAIC0yNTcsNiArMjU3LDcgQEAKIAlpZiAocmV0KQogCQlnb3RvIGNsa19mYWlsOwogCWRhdGEtPmNhcmQubnVtX2xpbmtzID0gMTsKKwlkYXRhLT5jYXJkLm93bmVyID0gVEhJU19NT0RVTEU7CiAJZGF0YS0+Y2FyZC5kYWlfbGluayA9ICZkYXRhLT5kYWk7CiAJZGF0YS0+Y2FyZC5kYXBtX3dpZGdldHMgPSBpbXhfd204OTYyX2RhcG1fd2lkZ2V0czsKIAlkYXRhLT5jYXJkLm51bV9kYXBtX3dpZGdldHMgPSBBUlJBWV9TSVpFKGlteF93bTg5NjJfZGFwbV93aWRnZXRzKTsKZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9nZW5lcmljL3NpbXBsZS1jYXJkLmMgYi9zb3VuZC9zb2MvZ2VuZXJpYy9zaW1wbGUtY2FyZC5jCmluZGV4IGZiOTI0MGYuLjdmZTMwMDkgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9nZW5lcmljL3NpbXBsZS1jYXJkLmMKKysrIGIvc291bmQvc29jL2dlbmVyaWMvc2ltcGxlLWNhcmQuYwpAQCAtNDUyLDkgKzQ1Miw4IEBACiB9CiAKIC8qIERlY3JlYXNlIHRoZSByZWZlcmVuY2UgY291bnQgb2YgdGhlIGRldmljZSBub2RlcyAqLwotc3RhdGljIGludCBhc29jX3NpbXBsZV9jYXJkX3VucmVmKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCitzdGF0aWMgaW50IGFzb2Nfc2ltcGxlX2NhcmRfdW5yZWYoc3RydWN0IHNuZF9zb2NfY2FyZCAqY2FyZCkKIHsKLQlzdHJ1Y3Qgc25kX3NvY19jYXJkICpjYXJkID0gcGxhdGZvcm1fZ2V0X2RydmRhdGEocGRldik7CiAJc3RydWN0IHNuZF9zb2NfZGFpX2xpbmsgKmRhaV9saW5rOwogCWludCBudW1fbGlua3M7CiAKQEAgLTU1Niw3ICs1NTUsNyBAQAogCQlyZXR1cm4gcmV0OwogCiBlcnI6Ci0JYXNvY19zaW1wbGVfY2FyZF91bnJlZihwZGV2KTsKKwlhc29jX3NpbXBsZV9jYXJkX3VucmVmKCZwcml2LT5zbmRfY2FyZCk7CiAJcmV0dXJuIHJldDsKIH0KIApAQCAtNTcyLDcgKzU3MSw3IEBACiAJCXNuZF9zb2NfamFja19mcmVlX2dwaW9zKCZzaW1wbGVfY2FyZF9taWNfamFjaywgMSwKIAkJCQkJJnNpbXBsZV9jYXJkX21pY19qYWNrX2dwaW8pOwogCi0JcmV0dXJuIGFzb2Nfc2ltcGxlX2NhcmRfdW5yZWYocGRldik7CisJcmV0dXJuIGFzb2Nfc2ltcGxlX2NhcmRfdW5yZWYoY2FyZCk7CiB9CiAKIHN0YXRpYyBjb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkIGFzb2Nfc2ltcGxlX29mX21hdGNoW10gPSB7CmRpZmYgLS1naXQgYS9zb3VuZC9zb2MvaW50ZWwvc3N0LWZpcm13YXJlLmMgYi9zb3VuZC9zb2MvaW50ZWwvc3N0LWZpcm13YXJlLmMKaW5kZXggZWYyZThiNS4uYjNmOTQ4OSAxMDA2NDQKLS0tIGEvc291bmQvc29jL2ludGVsL3NzdC1maXJtd2FyZS5jCisrKyBiL3NvdW5kL3NvYy9pbnRlbC9zc3QtZmlybXdhcmUuYwpAQCAtNzA2LDYgKzcwNiw3IEBACiAJc3RydWN0IGxpc3RfaGVhZCAqYmxvY2tfbGlzdCkKIHsKIAlzdHJ1Y3Qgc3N0X21lbV9ibG9jayAqYmxvY2ssICp0bXA7CisJc3RydWN0IHNzdF9ibG9ja19hbGxvY2F0b3IgYmFfdG1wID0gKmJhOwogCXUzMiBlbmQgPSBiYS0+b2Zmc2V0ICsgYmEtPnNpemUsIGJsb2NrX2VuZDsKIAlpbnQgZXJyOwogCkBAIC03MzAsOSArNzMxLDkgQEAKIAkJaWYgKGJhLT5vZmZzZXQgPj0gYmxvY2stPm9mZnNldCAmJiBiYS0+b2Zmc2V0IDwgYmxvY2tfZW5kKSB7CiAKIAkJCS8qIGFsaWduIGJhIHRvIGJsb2NrIGJvdW5kYXJ5ICovCi0JCQliYS0+c2l6ZSAtPSBibG9ja19lbmQgLSBiYS0+b2Zmc2V0OwotCQkJYmEtPm9mZnNldCA9IGJsb2NrX2VuZDsKLQkJCWVyciA9IGJsb2NrX2FsbG9jX2NvbnRpZ3VvdXMoZHNwLCBiYSwgYmxvY2tfbGlzdCk7CisJCQliYV90bXAuc2l6ZSAtPSBibG9ja19lbmQgLSBiYS0+b2Zmc2V0OworCQkJYmFfdG1wLm9mZnNldCA9IGJsb2NrX2VuZDsKKwkJCWVyciA9IGJsb2NrX2FsbG9jX2NvbnRpZ3VvdXMoZHNwLCAmYmFfdG1wLCBibG9ja19saXN0KTsKIAkJCWlmIChlcnIgPCAwKQogCQkJCXJldHVybiAtRU5PTUVNOwogCkBAIC03NjcsMTAgKzc2OCwxMCBAQAogCQkJbGlzdF9tb3ZlKCZibG9jay0+bGlzdCwgJmRzcC0+dXNlZF9ibG9ja19saXN0KTsKIAkJCWxpc3RfYWRkKCZibG9jay0+bW9kdWxlX2xpc3QsIGJsb2NrX2xpc3QpOwogCQkJLyogYWxpZ24gYmEgdG8gYmxvY2sgYm91bmRhcnkgKi8KLQkJCWJhLT5zaXplIC09IGJsb2NrX2VuZCAtIGJhLT5vZmZzZXQ7Ci0JCQliYS0+b2Zmc2V0ID0gYmxvY2tfZW5kOworCQkJYmFfdG1wLnNpemUgLT0gYmxvY2tfZW5kIC0gYmEtPm9mZnNldDsKKwkJCWJhX3RtcC5vZmZzZXQgPSBibG9ja19lbmQ7CiAKLQkJCWVyciA9IGJsb2NrX2FsbG9jX2NvbnRpZ3VvdXMoZHNwLCBiYSwgYmxvY2tfbGlzdCk7CisJCQllcnIgPSBibG9ja19hbGxvY19jb250aWd1b3VzKGRzcCwgJmJhX3RtcCwgYmxvY2tfbGlzdCk7CiAJCQlpZiAoZXJyIDwgMCkKIAkJCQlyZXR1cm4gLUVOT01FTTsKIApkaWZmIC0tZ2l0IGEvc291bmQvc29jL2ludGVsL3NzdC1oYXN3ZWxsLWlwYy5jIGIvc291bmQvc29jL2ludGVsL3NzdC1oYXN3ZWxsLWlwYy5jCmluZGV4IDNmOGM0ODIuLjgxNTZjYzEgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9pbnRlbC9zc3QtaGFzd2VsbC1pcGMuYworKysgYi9zb3VuZC9zb2MvaW50ZWwvc3N0LWhhc3dlbGwtaXBjLmMKQEAgLTY1MSwxMSArNjUxLDExIEBACiAJfQogCiAJLyogdGVsbCBEU1AgdGhhdCBub3RpZmljYXRpb24gaGFzIGJlZW4gaGFuZGxlZCAqLwotCXNzdF9kc3Bfc2hpbV91cGRhdGVfYml0c191bmxvY2tlZChoc3ctPmRzcCwgU1NUX0lQQ0QsCisJc3N0X2RzcF9zaGltX3VwZGF0ZV9iaXRzKGhzdy0+ZHNwLCBTU1RfSVBDRCwKIAkJU1NUX0lQQ0RfQlVTWSB8IFNTVF9JUENEX0RPTkUsIFNTVF9JUENEX0RPTkUpOwogCiAJLyogdW5tYXNrIGJ1c3kgaW50ZXJydXB0ICovCi0Jc3N0X2RzcF9zaGltX3VwZGF0ZV9iaXRzX3VubG9ja2VkKGhzdy0+ZHNwLCBTU1RfSU1SWCwgU1NUX0lNUlhfQlVTWSwgMCk7CisJc3N0X2RzcF9zaGltX3VwZGF0ZV9iaXRzKGhzdy0+ZHNwLCBTU1RfSU1SWCwgU1NUX0lNUlhfQlVTWSwgMCk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXBjX21lc3NhZ2UgKnJlcGx5X2ZpbmRfbXNnKHN0cnVjdCBzc3RfaHN3ICpoc3csIHUzMiBoZWFkZXIpCkBAIC0xMjI4LDYgKzEyMjgsMTEgQEAKIAlzdHJ1Y3Qgc3N0X2RzcCAqc3N0ID0gaHN3LT5kc3A7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAorCWlmICghc3RyZWFtKSB7CisJCWRldl93YXJuKGhzdy0+ZGV2LCAid2FybmluZzogc3RyZWFtIGlzIE5VTEwsIG5vIHN0cmVhbSB0byBmcmVlLCBpZ25vcmUgaXQuXG4iKTsKKwkJcmV0dXJuIDA7CisJfQorCiAJLyogZG9udCBmcmVlIERTUCBzdHJlYW1zIHRoYXQgYXJlIG5vdCBjb21taXRlZCAqLwogCWlmICghc3RyZWFtLT5jb21taXRlZCkKIAkJZ290byBvdXQ7CkBAIC0xNDE1LDYgKzE0MjAsMTYgQEAKIAl1MzIgaGVhZGVyOwogCWludCByZXQ7CiAKKwlpZiAoIXN0cmVhbSkgeworCQlkZXZfd2Fybihoc3ctPmRldiwgIndhcm5pbmc6IHN0cmVhbSBpcyBOVUxMLCBubyBzdHJlYW0gdG8gY29tbWl0LCBpZ25vcmUgaXQuXG4iKTsKKwkJcmV0dXJuIDA7CisJfQorCisJaWYgKHN0cmVhbS0+Y29tbWl0ZWQpIHsKKwkJZGV2X3dhcm4oaHN3LT5kZXYsICJ3YXJuaW5nOiBzdHJlYW0gaXMgYWxyZWFkeSBjb21taXR0ZWQsIGlnbm9yZSBpdC5cbiIpOworCQlyZXR1cm4gMDsKKwl9CisKIAl0cmFjZV9pcGNfcmVxdWVzdCgic3RyZWFtIGFsbG9jIiwgc3RyZWFtLT5ob3N0X2lkKTsKIAogCWhlYWRlciA9IElQQ19HTEJfVFlQRShJUENfR0xCX0FMTE9DQVRFX1NUUkVBTSk7CkBAIC0xNTE5LDYgKzE1MzQsMTEgQEAKIHsKIAlpbnQgcmV0OwogCisJaWYgKCFzdHJlYW0pIHsKKwkJZGV2X3dhcm4oaHN3LT5kZXYsICJ3YXJuaW5nOiBzdHJlYW0gaXMgTlVMTCwgbm8gc3RyZWFtIHRvIHBhdXNlLCBpZ25vcmUgaXQuXG4iKTsKKwkJcmV0dXJuIDA7CisJfQorCiAJdHJhY2VfaXBjX3JlcXVlc3QoInN0cmVhbSBwYXVzZSIsIHN0cmVhbS0+cmVwbHkuc3RyZWFtX2h3X2lkKTsKIAogCXJldCA9IHNzdF9oc3dfc3RyZWFtX29wZXJhdGlvbnMoaHN3LCBJUENfU1RSX1BBVVNFLApAQCAtMTUzNSw2ICsxNTU1LDExIEBACiB7CiAJaW50IHJldDsKIAorCWlmICghc3RyZWFtKSB7CisJCWRldl93YXJuKGhzdy0+ZGV2LCAid2FybmluZzogc3RyZWFtIGlzIE5VTEwsIG5vIHN0cmVhbSB0byByZXN1bWUsIGlnbm9yZSBpdC5cbiIpOworCQlyZXR1cm4gMDsKKwl9CisKIAl0cmFjZV9pcGNfcmVxdWVzdCgic3RyZWFtIHJlc3VtZSIsIHN0cmVhbS0+cmVwbHkuc3RyZWFtX2h3X2lkKTsKIAogCXJldCA9IHNzdF9oc3dfc3RyZWFtX29wZXJhdGlvbnMoaHN3LCBJUENfU1RSX1JFU1VNRSwKQEAgLTE1NTAsNiArMTU3NSwxMSBAQAogewogCWludCByZXQsIHRyaWVzID0gMTA7CiAKKwlpZiAoIXN0cmVhbSkgeworCQlkZXZfd2Fybihoc3ctPmRldiwgIndhcm5pbmc6IHN0cmVhbSBpcyBOVUxMLCBubyBzdHJlYW0gdG8gcmVzZXQsIGlnbm9yZSBpdC5cbiIpOworCQlyZXR1cm4gMDsKKwl9CisKIAkvKiBkb250IHJlc2V0IHN0cmVhbXMgdGhhdCBhcmUgbm90IGNvbW1pdGVkICovCiAJaWYgKCFzdHJlYW0tPmNvbW1pdGVkKQogCQlyZXR1cm4gMDsKZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9pbnRlbC9zc3Qvc3N0X2FjcGkuYyBiL3NvdW5kL3NvYy9pbnRlbC9zc3Qvc3N0X2FjcGkuYwppbmRleCAyYWM3MmViLi5iMzM2MDEzIDEwMDY0NAotLS0gYS9zb3VuZC9zb2MvaW50ZWwvc3N0L3NzdF9hY3BpLmMKKysrIGIvc291bmQvc29jL2ludGVsL3NzdC9zc3RfYWNwaS5jCkBAIC0zNTAsNyArMzUwLDcgQEAKIAogLyogQ2hlcnJ5dmlldy1iYXNlZCBwbGF0Zm9ybXM6IENoZXJyeVRyYWlsIGFuZCBCcmFzd2VsbCAqLwogc3RhdGljIHN0cnVjdCBzc3RfbWFjaGluZXMgc3N0X2FjcGlfY2h2W10gPSB7Ci0JeyIxMEVDNTY3MCIsICJjaHQtYnN3IiwgImNodC1ic3ctcnQ1NjcyIiwgTlVMTCwgImZ3X3NzdF8yMmE4LmJpbiIsCisJeyIxMEVDNTY3MCIsICJjaHQtYnN3IiwgImNodC1ic3ctcnQ1NjcyIiwgTlVMTCwgImludGVsL2Z3X3NzdF8yMmE4LmJpbiIsCiAJCQkJCQkmY2h2X3BsYXRmb3JtX2RhdGEgfSwKIAl7fSwKIH07CmRpZmYgLS1naXQgYS9zb3VuZC9zb2Mvb21hcC9vbWFwLW1jYnNwLmMgYi9zb3VuZC9zb2Mvb21hcC9vbWFwLW1jYnNwLmMKaW5kZXggOGI3OWNhZmEuLmM3ZWI5ZGQgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9vbWFwL29tYXAtbWNic3AuYworKysgYi9zb3VuZC9zb2Mvb21hcC9vbWFwLW1jYnNwLmMKQEAgLTQzNCw3ICs0MzQsNyBAQAogCWNhc2UgU05EX1NPQ19EQUlGTVRfQ0JNX0NGUzoKIAkJLyogTWNCU1Agc2xhdmUuIEZTIGNsb2NrIGFzIG91dHB1dCAqLwogCQlyZWdzLT5zcmdyMgl8PSBGU0dNOwotCQlyZWdzLT5wY3IwCXw9IEZTWE07CisJCXJlZ3MtPnBjcjAJfD0gRlNYTSB8IEZTUk07CiAJCWJyZWFrOwogCWNhc2UgU05EX1NPQ19EQUlGTVRfQ0JNX0NGTToKIAkJLyogTWNCU1Agc2xhdmUgKi8KZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9yb2NrY2hpcC9yb2NrY2hpcF9pMnMuYyBiL3NvdW5kL3NvYy9yb2NrY2hpcC9yb2NrY2hpcF9pMnMuYwppbmRleCAxM2Q4NTA3Li5kY2MyNmVkIDEwMDY0NAotLS0gYS9zb3VuZC9zb2Mvcm9ja2NoaXAvcm9ja2NoaXBfaTJzLmMKKysrIGIvc291bmQvc29jL3JvY2tjaGlwL3JvY2tjaGlwX2kycy5jCkBAIC0zMzUsNiArMzM1LDcgQEAKIAkJCSAgICBTTkRSVl9QQ01fRk1UQklUX1MyNF9MRSksCiAJfSwKIAkub3BzID0gJnJvY2tjaGlwX2kyc19kYWlfb3BzLAorCS5zeW1tZXRyaWNfcmF0ZXMgPSAxLAogfTsKIAogc3RhdGljIGNvbnN0IHN0cnVjdCBzbmRfc29jX2NvbXBvbmVudF9kcml2ZXIgcm9ja2NoaXBfaTJzX2NvbXBvbmVudCA9IHsKZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9zb2MtYWM5Ny5jIGIvc291bmQvc29jL3NvYy1hYzk3LmMKaW5kZXggMmUxMGU5YS4uMDhkNzI1OSAxMDA2NDQKLS0tIGEvc291bmQvc29jL3NvYy1hYzk3LmMKKysrIGIvc291bmQvc29jL3NvYy1hYzk3LmMKQEAgLTQ4LDE1ICs0OCwxOCBAQAogfQogCiAvKioKLSAqIHNuZF9zb2NfbmV3X2FjOTdfY29kZWMgLSBpbml0YWlsaXNlIEFDOTcgZGV2aWNlCi0gKiBAY29kZWM6IGF1ZGlvIGNvZGVjCisgKiBzbmRfc29jX2FsbG9jX2FjOTdfY29kZWMoKSAtIEFsbG9jYXRlIG5ldyBhIEFDJzk3IGRldmljZQorICogQGNvZGVjOiBUaGUgQ09ERUMgZm9yIHdoaWNoIHRvIGNyZWF0ZSB0aGUgQUMnOTcgZGV2aWNlCiAgKgotICogSW5pdGlhbGlzZXMgQUM5NyBjb2RlYyByZXNvdXJjZXMgZm9yIHVzZSBieSBhZC1ob2MgZGV2aWNlcyBvbmx5LgorICogQWxsb2NhdGVkIGEgbmV3IHNuZF9hYzk3IGRldmljZSBhbmQgaW50aWFsaXplcyBpdCwgYnV0IGRvZXMgbm90IHlldCByZWdpc3RlcgorICogaXQuIFRoZSBjYWxsZXIgaXMgcmVzcG9uc2libGUgdG8gZWl0aGVyIGNhbGwgZGV2aWNlX2FkZCgmYWM5Ny0+ZGV2KSB0bworICogcmVnaXN0ZXIgdGhlIGRldmljZSwgb3IgdG8gY2FsbCBwdXRfZGV2aWNlKCZhYzk3LT5kZXYpIHRvIGZyZWUgdGhlIGRldmljZS4KKyAqCisgKiBSZXR1cm5zOiBBIHNuZF9hYzk3IGRldmljZSBvciBhIFBUUl9FUlIgaW4gY2FzZSBvZiBhbiBlcnJvci4KICAqLwotc3RydWN0IHNuZF9hYzk3ICpzbmRfc29jX25ld19hYzk3X2NvZGVjKHN0cnVjdCBzbmRfc29jX2NvZGVjICpjb2RlYykKK3N0cnVjdCBzbmRfYWM5NyAqc25kX3NvY19hbGxvY19hYzk3X2NvZGVjKHN0cnVjdCBzbmRfc29jX2NvZGVjICpjb2RlYykKIHsKIAlzdHJ1Y3Qgc25kX2FjOTcgKmFjOTc7Ci0JaW50IHJldDsKIAogCWFjOTcgPSBremFsbG9jKHNpemVvZihzdHJ1Y3Qgc25kX2FjOTcpLCBHRlBfS0VSTkVMKTsKIAlpZiAoYWM5NyA9PSBOVUxMKQpAQCAtNzMsNyArNzYsMjggQEAKIAkJICAgICBjb2RlYy0+Y29tcG9uZW50LmNhcmQtPnNuZF9jYXJkLT5udW1iZXIsIDAsCiAJCSAgICAgY29kZWMtPmNvbXBvbmVudC5uYW1lKTsKIAotCXJldCA9IGRldmljZV9yZWdpc3RlcigmYWM5Ny0+ZGV2KTsKKwlkZXZpY2VfaW5pdGlhbGl6ZSgmYWM5Ny0+ZGV2KTsKKworCXJldHVybiBhYzk3OworfQorRVhQT1JUX1NZTUJPTChzbmRfc29jX2FsbG9jX2FjOTdfY29kZWMpOworCisvKioKKyAqIHNuZF9zb2NfbmV3X2FjOTdfY29kZWMgLSBpbml0YWlsaXNlIEFDOTcgZGV2aWNlCisgKiBAY29kZWM6IGF1ZGlvIGNvZGVjCisgKgorICogSW5pdGlhbGlzZXMgQUM5NyBjb2RlYyByZXNvdXJjZXMgZm9yIHVzZSBieSBhZC1ob2MgZGV2aWNlcyBvbmx5LgorICovCitzdHJ1Y3Qgc25kX2FjOTcgKnNuZF9zb2NfbmV3X2FjOTdfY29kZWMoc3RydWN0IHNuZF9zb2NfY29kZWMgKmNvZGVjKQoreworCXN0cnVjdCBzbmRfYWM5NyAqYWM5NzsKKwlpbnQgcmV0OworCisJYWM5NyA9IHNuZF9zb2NfYWxsb2NfYWM5N19jb2RlYyhjb2RlYyk7CisJaWYgKElTX0VSUihhYzk3KSkKKwkJcmV0dXJuIGFjOTc7CisKKwlyZXQgPSBkZXZpY2VfYWRkKCZhYzk3LT5kZXYpOwogCWlmIChyZXQpIHsKIAkJcHV0X2RldmljZSgmYWM5Ny0+ZGV2KTsKIAkJcmV0dXJuIEVSUl9QVFIocmV0KTsKZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9zb2MtY29tcHJlc3MuYyBiL3NvdW5kL3NvYy9zb2MtY29tcHJlc3MuYwppbmRleCA1OTBhODJmLi4wMjVjMzhmIDEwMDY0NAotLS0gYS9zb3VuZC9zb2Mvc29jLWNvbXByZXNzLmMKKysrIGIvc291bmQvc29jL3NvYy1jb21wcmVzcy5jCkBAIC02NTksNyArNjU5LDggQEAKIAkJCXJ0ZC0+ZGFpX2xpbmstPnN0cmVhbV9uYW1lKTsKIAogCQlyZXQgPSBzbmRfcGNtX25ld19pbnRlcm5hbChydGQtPmNhcmQtPnNuZF9jYXJkLCBuZXdfbmFtZSwgbnVtLAotCQkJCTEsIDAsICZiZV9wY20pOworCQkJCXJ0ZC0+ZGFpX2xpbmstPmRwY21fcGxheWJhY2ssCisJCQkJcnRkLT5kYWlfbGluay0+ZHBjbV9jYXB0dXJlLCAmYmVfcGNtKTsKIAkJaWYgKHJldCA8IDApIHsKIAkJCWRldl9lcnIocnRkLT5jYXJkLT5kZXYsICJBU29DOiBjYW4ndCBjcmVhdGUgY29tcHJlc3NlZCBmb3IgJXNcbiIsCiAJCQkJcnRkLT5kYWlfbGluay0+bmFtZSk7CkBAIC02NjgsOCArNjY5LDEwIEBACiAKIAkJcnRkLT5wY20gPSBiZV9wY207CiAJCXJ0ZC0+ZmVfY29tcHIgPSAxOwotCQliZV9wY20tPnN0cmVhbXNbU05EUlZfUENNX1NUUkVBTV9QTEFZQkFDS10uc3Vic3RyZWFtLT5wcml2YXRlX2RhdGEgPSBydGQ7Ci0JCWJlX3BjbS0+c3RyZWFtc1tTTkRSVl9QQ01fU1RSRUFNX0NBUFRVUkVdLnN1YnN0cmVhbS0+cHJpdmF0ZV9kYXRhID0gcnRkOworCQlpZiAocnRkLT5kYWlfbGluay0+ZHBjbV9wbGF5YmFjaykKKwkJCWJlX3BjbS0+c3RyZWFtc1tTTkRSVl9QQ01fU1RSRUFNX1BMQVlCQUNLXS5zdWJzdHJlYW0tPnByaXZhdGVfZGF0YSA9IHJ0ZDsKKwkJZWxzZSBpZiAocnRkLT5kYWlfbGluay0+ZHBjbV9jYXB0dXJlKQorCQkJYmVfcGNtLT5zdHJlYW1zW1NORFJWX1BDTV9TVFJFQU1fQ0FQVFVSRV0uc3Vic3RyZWFtLT5wcml2YXRlX2RhdGEgPSBydGQ7CiAJCW1lbWNweShjb21wci0+b3BzLCAmc29jX2NvbXByX2R5bl9vcHMsIHNpemVvZihzb2NfY29tcHJfZHluX29wcykpOwogCX0gZWxzZQogCQltZW1jcHkoY29tcHItPm9wcywgJnNvY19jb21wcl9vcHMsIHNpemVvZihzb2NfY29tcHJfb3BzKSk7CmRpZmYgLS1naXQgYS9zb3VuZC91c2IvbWl4ZXIuYyBiL3NvdW5kL3VzYi9taXhlci5jCmluZGV4IDQxNjUwZDUuLjNlMmVmNjEgMTAwNjQ0Ci0tLSBhL3NvdW5kL3VzYi9taXhlci5jCisrKyBiL3NvdW5kL3VzYi9taXhlci5jCkBAIC05MTMsNiArOTEzLDcgQEAKIAljYXNlIFVTQl9JRCgweDA0NmQsIDB4MDgwNyk6IC8qIExvZ2l0ZWNoIFdlYmNhbSBDNTAwICovCiAJY2FzZSBVU0JfSUQoMHgwNDZkLCAweDA4MDgpOgogCWNhc2UgVVNCX0lEKDB4MDQ2ZCwgMHgwODA5KToKKwljYXNlIFVTQl9JRCgweDA0NmQsIDB4MDgxOSk6IC8qIExvZ2l0ZWNoIFdlYmNhbSBDMjEwICovCiAJY2FzZSBVU0JfSUQoMHgwNDZkLCAweDA4MWIpOiAvKiBIRCBXZWJjYW0gYzMxMCAqLwogCWNhc2UgVVNCX0lEKDB4MDQ2ZCwgMHgwODFkKTogLyogSEQgV2ViY2FtIGM1MTAgKi8KIAljYXNlIFVTQl9JRCgweDA0NmQsIDB4MDgyNSk6IC8qIEhEIFdlYmNhbSBjMjcwICovCmRpZmYgLS1naXQgYS90b29scy9saWIvbG9ja2RlcC8uZ2l0aWdub3JlIGIvdG9vbHMvbGliL2xvY2tkZXAvLmdpdGlnbm9yZQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jYzBlN2E5Ci0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvbGliL2xvY2tkZXAvLmdpdGlnbm9yZQpAQCAtMCwwICsxIEBACitsaWJsb2NrZGVwLnNvLioKZGlmZiAtLWdpdCBhL3Rvb2xzL2xpYi9sb2NrZGVwL01ha2VmaWxlIGIvdG9vbHMvbGliL2xvY2tkZXAvTWFrZWZpbGUKaW5kZXggNTJmOTI3OS4uNGI4NjZjNSAxMDA2NDQKLS0tIGEvdG9vbHMvbGliL2xvY2tkZXAvTWFrZWZpbGUKKysrIGIvdG9vbHMvbGliL2xvY2tkZXAvTWFrZWZpbGUKQEAgLTEwNCw3ICsxMDQsNyBAQAogCiBleHBvcnQgUSBWRVJCT1NFCiAKLUlOQ0xVREVTID0gLUkuIC1JL3Vzci9sb2NhbC9pbmNsdWRlIC1JLi91aW5jbHVkZSAtSS4vaW5jbHVkZSAtSS4uLy4uL2luY2x1ZGUgJChDT05GSUdfSU5DTFVERVMpCitJTkNMVURFUyA9IC1JLiAtSS4vdWluY2x1ZGUgLUkuL2luY2x1ZGUgLUkuLi8uLi9pbmNsdWRlICQoQ09ORklHX0lOQ0xVREVTKQogCiAjIFNldCBjb21waWxlIG9wdGlvbiBDRkxBR1MgaWYgbm90IHNldCBlbHNld2hlcmUKIENGTEFHUyA/PSAtZyAtRENPTkZJR19MT0NLREVQIC1EQ09ORklHX1NUQUNLVFJBQ0UgLURDT05GSUdfUFJPVkVfTE9DS0lORyAtREJJVFNfUEVSX0xPTkc9X19XT1JEU0laRSAtRExJQkxPQ0tERVBfVkVSU0lPTj0nIiQoTElCTE9DS0RFUF9WRVJTSU9OKSInIC1yZHluYW1pYyAtTzAgLWcKZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvc2NyaXB0cy9wZXJsL1BlcmYtVHJhY2UtVXRpbC9Db250ZXh0LmMgYi90b29scy9wZXJmL3NjcmlwdHMvcGVybC9QZXJmLVRyYWNlLVV0aWwvQ29udGV4dC5jCmluZGV4IDc5MGNlYmEuLjI4NDMxZDEgMTAwNjQ0Ci0tLSBhL3Rvb2xzL3BlcmYvc2NyaXB0cy9wZXJsL1BlcmYtVHJhY2UtVXRpbC9Db250ZXh0LmMKKysrIGIvdG9vbHMvcGVyZi9zY3JpcHRzL3BlcmwvUGVyZi1UcmFjZS1VdGlsL0NvbnRleHQuYwpAQCAtNSw3ICs1LDEwIEBACiAgKglBTlkgQ0hBTkdFUyBNQURFIEhFUkUgV0lMTCBCRSBMT1NUISAKICAqCiAgKi8KLQorI2luY2x1ZGUgPHN0ZGJvb2wuaD4KKyNpZm5kZWYgSEFTX0JPT0wKKyMgZGVmaW5lIEhBU19CT09MIDEKKyNlbmRpZgogI2xpbmUgMSAiQ29udGV4dC54cyIKIC8qCiAgKiBDb250ZXh0LnhzLiAgWFMgaW50ZXJmYWNlcyBmb3IgcGVyZiBzY3JpcHQuCmRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvYW5ub3RhdGUuYyBiL3Rvb2xzL3BlcmYvdXRpbC9hbm5vdGF0ZS5jCmluZGV4IDc5OTk5Y2UuLjAxYmM0ZTIgMTAwNjQ0Ci0tLSBhL3Rvb2xzL3BlcmYvdXRpbC9hbm5vdGF0ZS5jCisrKyBiL3Rvb2xzL3BlcmYvdXRpbC9hbm5vdGF0ZS5jCkBAIC0xNzcsMTQgKzE3NywxNyBAQAogCQlnb3RvIG91dF9mcmVlX29wczsKIAogCW9wcy0+bG9ja2VkLmlucyA9IGluc19fZmluZChuYW1lKTsKKwlmcmVlKG5hbWUpOworCiAJaWYgKG9wcy0+bG9ja2VkLmlucyA9PSBOVUxMKQogCQlnb3RvIG91dF9mcmVlX29wczsKIAogCWlmICghb3BzLT5sb2NrZWQuaW5zLT5vcHMpCiAJCXJldHVybiAwOwogCi0JaWYgKG9wcy0+bG9ja2VkLmlucy0+b3BzLT5wYXJzZSkKLQkJb3BzLT5sb2NrZWQuaW5zLT5vcHMtPnBhcnNlKG9wcy0+bG9ja2VkLm9wcyk7CisJaWYgKG9wcy0+bG9ja2VkLmlucy0+b3BzLT5wYXJzZSAmJgorCSAgICBvcHMtPmxvY2tlZC5pbnMtPm9wcy0+cGFyc2Uob3BzLT5sb2NrZWQub3BzKSA8IDApCisJCWdvdG8gb3V0X2ZyZWVfb3BzOwogCiAJcmV0dXJuIDA7CiAKQEAgLTIwOCw2ICsyMTEsMTMgQEAKIAogc3RhdGljIHZvaWQgbG9ja19fZGVsZXRlKHN0cnVjdCBpbnNfb3BlcmFuZHMgKm9wcykKIHsKKwlzdHJ1Y3QgaW5zICppbnMgPSBvcHMtPmxvY2tlZC5pbnM7CisKKwlpZiAoaW5zICYmIGlucy0+b3BzLT5mcmVlKQorCQlpbnMtPm9wcy0+ZnJlZShvcHMtPmxvY2tlZC5vcHMpOworCWVsc2UKKwkJaW5zX19kZWxldGUob3BzLT5sb2NrZWQub3BzKTsKKwogCXpmcmVlKCZvcHMtPmxvY2tlZC5vcHMpOwogCXpmcmVlKCZvcHMtPnRhcmdldC5yYXcpOwogCXpmcmVlKCZvcHMtPnRhcmdldC5uYW1lKTsKQEAgLTUzMSw4ICs1NDEsOCBAQAogCWlmICghZGwtPmlucy0+b3BzKQogCQlyZXR1cm47CiAKLQlpZiAoZGwtPmlucy0+b3BzLT5wYXJzZSkKLQkJZGwtPmlucy0+b3BzLT5wYXJzZSgmZGwtPm9wcyk7CisJaWYgKGRsLT5pbnMtPm9wcy0+cGFyc2UgJiYgZGwtPmlucy0+b3BzLT5wYXJzZSgmZGwtPm9wcykgPCAwKQorCQlkbC0+aW5zID0gTlVMTDsKIH0KIAogc3RhdGljIGludCBkaXNhc21fbGluZV9fcGFyc2UoY2hhciAqbGluZSwgY2hhciAqKm5hbWVwLCBjaGFyICoqcmF3cCkKZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvdXRpbC9ldmxpc3QuYyBiL3Rvb2xzL3BlcmYvdXRpbC9ldmxpc3QuYwppbmRleCBjYmFiMWZiLi4yZTUwN2I1IDEwMDY0NAotLS0gYS90b29scy9wZXJmL3V0aWwvZXZsaXN0LmMKKysrIGIvdG9vbHMvcGVyZi91dGlsL2V2bGlzdC5jCkBAIC0xNDQ1LDcgKzE0NDUsNyBAQAogCWNhc2UgRU5PRU5UOgogCQlzY25wcmludGYoYnVmLCBzaXplLCAiJXMiLAogCQkJICAiRXJyb3I6XHRVbmFibGUgdG8gZmluZCBkZWJ1Z2ZzXG4iCi0JCQkgICJIaW50Olx0V2FzIHlvdXIga2VybmVsIHdhcyBjb21waWxlZCB3aXRoIGRlYnVnZnMgc3VwcG9ydD9cbiIKKwkJCSAgIkhpbnQ6XHRXYXMgeW91ciBrZXJuZWwgY29tcGlsZWQgd2l0aCBkZWJ1Z2ZzIHN1cHBvcnQ/XG4iCiAJCQkgICJIaW50Olx0SXMgdGhlIGRlYnVnZnMgZmlsZXN5c3RlbSBtb3VudGVkP1xuIgogCQkJICAiSGludDpcdFRyeSAnc3VkbyBtb3VudCAtdCBkZWJ1Z2ZzIG5vZGV2IC9zeXMva2VybmVsL2RlYnVnJyIpOwogCQlicmVhazsKZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvdXRpbC9tYXAuaCBiL3Rvb2xzL3BlcmYvdXRpbC9tYXAuaAppbmRleCA2OTUxYTlkLi4wZTQyNDM4IDEwMDY0NAotLS0gYS90b29scy9wZXJmL3V0aWwvbWFwLmgKKysrIGIvdG9vbHMvcGVyZi91dGlsL21hcC5oCkBAIC0xMTYsNiArMTE2LDIyIEBACiAjZGVmaW5lIG1hcF9fZm9yX2VhY2hfc3ltYm9sKG1hcCwgcG9zLCBuKQlcCiAJZHNvX19mb3JfZWFjaF9zeW1ib2wobWFwLT5kc28sIHBvcywgbiwgbWFwLT50eXBlKQogCisvKiBtYXBfX2Zvcl9lYWNoX3N5bWJvbF93aXRoX25hbWUgLSBpdGVyYXRlIG92ZXIgdGhlIHN5bWJvbHMgaW4gdGhlIGdpdmVuIG1hcAorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdGhhdCBoYXZlIHRoZSBnaXZlbiBuYW1lCisgKgorICogQG1hcDogdGhlICdzdHJ1Y3QgbWFwIConIGluIHdoaWNoIHN5bWJvbHMgaXRlcmVhdGVkCisgKiBAc3ltX25hbWU6IHRoZSBzeW1ib2wgbmFtZQorICogQHBvczogdGhlICdzdHJ1Y3Qgc3ltYm9sIConIHRvIHVzZSBhcyBhIGxvb3AgY3Vyc29yCisgKiBAZmlsdGVyOiB0byB1c2Ugd2hlbiBsb2FkaW5nIHRoZSBEU08KKyAqLworI2RlZmluZSBfX21hcF9fZm9yX2VhY2hfc3ltYm9sX2J5X25hbWUobWFwLCBzeW1fbmFtZSwgcG9zLCBmaWx0ZXIpCVwKKwlmb3IgKHBvcyA9IG1hcF9fZmluZF9zeW1ib2xfYnlfbmFtZShtYXAsIHN5bV9uYW1lLCBmaWx0ZXIpOwlcCisJICAgICBwb3MgJiYgc3RyY21wKHBvcy0+bmFtZSwgc3ltX25hbWUpID09IDA7CQlcCisJICAgICBwb3MgPSBzeW1ib2xfX25leHRfYnlfbmFtZShwb3MpKQorCisjZGVmaW5lIG1hcF9fZm9yX2VhY2hfc3ltYm9sX2J5X25hbWUobWFwLCBzeW1fbmFtZSwgcG9zKQkJXAorCV9fbWFwX19mb3JfZWFjaF9zeW1ib2xfYnlfbmFtZShtYXAsIHN5bV9uYW1lLCAocG9zKSwgTlVMTCkKKwogdHlwZWRlZiBpbnQgKCpzeW1ib2xfZmlsdGVyX3QpKHN0cnVjdCBtYXAgKm1hcCwgc3RydWN0IHN5bWJvbCAqc3ltKTsKIAogdm9pZCBtYXBfX2luaXQoc3RydWN0IG1hcCAqbWFwLCBlbnVtIG1hcF90eXBlIHR5cGUsCmRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvcHJvYmUtZXZlbnQuYyBiL3Rvb2xzL3BlcmYvdXRpbC9wcm9iZS1ldmVudC5jCmluZGV4IDk0YTcxN2IuLjkxOTkzN2UgMTAwNjQ0Ci0tLSBhL3Rvb2xzL3BlcmYvdXRpbC9wcm9iZS1ldmVudC5jCisrKyBiL3Rvb2xzL3BlcmYvdXRpbC9wcm9iZS1ldmVudC5jCkBAIC00NDYsNyArNDQ2LDcgQEAKIAl9CiAKIAlmb3IgKGkgPSAwOyBpIDwgbnRldnM7IGkrKykgewotCQlpZiAodGV2c1tpXS5wb2ludC5hZGRyZXNzKSB7CisJCWlmICh0ZXZzW2ldLnBvaW50LmFkZHJlc3MgJiYgIXRldnNbaV0ucG9pbnQucmV0cHJvYmUpIHsKIAkJCXRtcCA9IHN0cmR1cChyZWxvY19zeW0tPm5hbWUpOwogCQkJaWYgKCF0bXApCiAJCQkJcmV0dXJuIC1FTk9NRU07CkBAIC0yMTkzLDE4ICsyMTkzLDE3IEBACiAJcmV0dXJuIHJldDsKIH0KIAotc3RhdGljIGNoYXIgKmxvb2tpbmdfZnVuY3Rpb25fbmFtZTsKLXN0YXRpYyBpbnQgbnVtX21hdGNoZWRfZnVuY3Rpb25zOwotCi1zdGF0aWMgaW50IHByb2JlX2Z1bmN0aW9uX2ZpbHRlcihzdHJ1Y3QgbWFwICptYXAgX19tYXliZV91bnVzZWQsCi0JCQkJICAgICAgc3RydWN0IHN5bWJvbCAqc3ltKQorc3RhdGljIGludCBmaW5kX3Byb2JlX2Z1bmN0aW9ucyhzdHJ1Y3QgbWFwICptYXAsIGNoYXIgKm5hbWUpCiB7Ci0JaWYgKChzeW0tPmJpbmRpbmcgPT0gU1RCX0dMT0JBTCB8fCBzeW0tPmJpbmRpbmcgPT0gU1RCX0xPQ0FMKSAmJgotCSAgICBzdHJjbXAobG9va2luZ19mdW5jdGlvbl9uYW1lLCBzeW0tPm5hbWUpID09IDApIHsKLQkJbnVtX21hdGNoZWRfZnVuY3Rpb25zKys7Ci0JCXJldHVybiAwOworCWludCBmb3VuZCA9IDA7CisJc3RydWN0IHN5bWJvbCAqc3ltOworCisJbWFwX19mb3JfZWFjaF9zeW1ib2xfYnlfbmFtZShtYXAsIG5hbWUsIHN5bSkgeworCQlpZiAoc3ltLT5iaW5kaW5nID09IFNUQl9HTE9CQUwgfHwgc3ltLT5iaW5kaW5nID09IFNUQl9MT0NBTCkKKwkJCWZvdW5kKys7CiAJfQotCXJldHVybiAxOworCisJcmV0dXJuIGZvdW5kOwogfQogCiAjZGVmaW5lIHN0cmR1cF9vcl9nb3RvKHN0ciwgbGFiZWwpCVwKQEAgLTIyMjIsMTAgKzIyMjEsMTAgQEAKIAlzdHJ1Y3Qga21hcCAqa21hcCA9IE5VTEw7CiAJc3RydWN0IHJlZl9yZWxvY19zeW0gKnJlbG9jX3N5bSA9IE5VTEw7CiAJc3RydWN0IHN5bWJvbCAqc3ltOwotCXN0cnVjdCByYl9ub2RlICpuZDsKIAlzdHJ1Y3QgcHJvYmVfdHJhY2VfZXZlbnQgKnRldjsKIAlzdHJ1Y3QgcGVyZl9wcm9iZV9wb2ludCAqcHAgPSAmcGV2LT5wb2ludDsKIAlzdHJ1Y3QgcHJvYmVfdHJhY2VfcG9pbnQgKnRwOworCWludCBudW1fbWF0Y2hlZF9mdW5jdGlvbnM7CiAJaW50IHJldCwgaTsKIAogCS8qIEluaXQgbWFwcyBvZiBnaXZlbiBleGVjdXRhYmxlIG9yIGtlcm5lbCAqLwpAQCAtMjI0MiwxMCArMjI0MSw4IEBACiAJICogTG9hZCBtYXRjaGVkIHN5bWJvbHM6IFNpbmNlIHRoZSBkaWZmZXJlbnQgbG9jYWwgc3ltYm9scyBtYXkgaGF2ZQogCSAqIHNhbWUgbmFtZSBidXQgZGlmZmVyZW50IGFkZHJlc3NlcywgdGhpcyBsaXN0cyBhbGwgdGhlIHN5bWJvbHMuCiAJICovCi0JbnVtX21hdGNoZWRfZnVuY3Rpb25zID0gMDsKLQlsb29raW5nX2Z1bmN0aW9uX25hbWUgPSBwcC0+ZnVuY3Rpb247Ci0JcmV0ID0gbWFwX19sb2FkKG1hcCwgcHJvYmVfZnVuY3Rpb25fZmlsdGVyKTsKLQlpZiAocmV0IHx8IG51bV9tYXRjaGVkX2Z1bmN0aW9ucyA9PSAwKSB7CisJbnVtX21hdGNoZWRfZnVuY3Rpb25zID0gZmluZF9wcm9iZV9mdW5jdGlvbnMobWFwLCBwcC0+ZnVuY3Rpb24pOworCWlmIChudW1fbWF0Y2hlZF9mdW5jdGlvbnMgPT0gMCkgewogCQlwcl9lcnIoIkZhaWxlZCB0byBmaW5kIHN5bWJvbCAlcyBpbiAlc1xuIiwgcHAtPmZ1bmN0aW9uLAogCQkJdGFyZ2V0ID8gOiAia2VybmVsIik7CiAJCXJldCA9IC1FTk9FTlQ7CkBAIC0yMjU3LDcgKzIyNTQsNyBAQAogCQlnb3RvIG91dDsKIAl9CiAKLQlpZiAoIXBldi0+dXByb2JlcykgeworCWlmICghcGV2LT51cHJvYmVzICYmICFwcC0+cmV0cHJvYmUpIHsKIAkJa21hcCA9IG1hcF9fa21hcChtYXApOwogCQlyZWxvY19zeW0gPSBrbWFwLT5yZWZfcmVsb2Nfc3ltOwogCQlpZiAoIXJlbG9jX3N5bSkgewpAQCAtMjI3NSw3ICsyMjcyLDggQEAKIAl9CiAKIAlyZXQgPSAwOwotCW1hcF9fZm9yX2VhY2hfc3ltYm9sKG1hcCwgc3ltLCBuZCkgeworCisJbWFwX19mb3JfZWFjaF9zeW1ib2xfYnlfbmFtZShtYXAsIHBwLT5mdW5jdGlvbiwgc3ltKSB7CiAJCXRldiA9ICgqdGV2cykgKyByZXQ7CiAJCXRwID0gJnRldi0+cG9pbnQ7CiAJCWlmIChyZXQgPT0gbnVtX21hdGNoZWRfZnVuY3Rpb25zKSB7CmRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvc3ltYm9sLmMgYi90b29scy9wZXJmL3V0aWwvc3ltYm9sLmMKaW5kZXggYzI0YzViOC4uYTE5NDcwMiAxMDA2NDQKLS0tIGEvdG9vbHMvcGVyZi91dGlsL3N5bWJvbC5jCisrKyBiL3Rvb2xzL3BlcmYvdXRpbC9zeW1ib2wuYwpAQCAtMzk2LDYgKzM5Niw3IEBACiAJCQkJCSAgICBjb25zdCBjaGFyICpuYW1lKQogewogCXN0cnVjdCByYl9ub2RlICpuOworCXN0cnVjdCBzeW1ib2xfbmFtZV9yYl9ub2RlICpzOwogCiAJaWYgKHN5bWJvbHMgPT0gTlVMTCkKIAkJcmV0dXJuIE5VTEw7CkBAIC00MDMsNyArNDA0LDYgQEAKIAluID0gc3ltYm9scy0+cmJfbm9kZTsKIAogCXdoaWxlIChuKSB7Ci0JCXN0cnVjdCBzeW1ib2xfbmFtZV9yYl9ub2RlICpzOwogCQlpbnQgY21wOwogCiAJCXMgPSByYl9lbnRyeShuLCBzdHJ1Y3Qgc3ltYm9sX25hbWVfcmJfbm9kZSwgcmJfbm9kZSk7CkBAIC00MTQsMTAgKzQxNCwyNCBAQAogCQllbHNlIGlmIChjbXAgPiAwKQogCQkJbiA9IG4tPnJiX3JpZ2h0OwogCQllbHNlCi0JCQlyZXR1cm4gJnMtPnN5bTsKKwkJCWJyZWFrOwogCX0KIAotCXJldHVybiBOVUxMOworCWlmIChuID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCisJLyogcmV0dXJuIGZpcnN0IHN5bWJvbCB0aGF0IGhhcyBzYW1lIG5hbWUgKGlmIGFueSkgKi8KKwlmb3IgKG4gPSByYl9wcmV2KG4pOyBuOyBuID0gcmJfcHJldihuKSkgeworCQlzdHJ1Y3Qgc3ltYm9sX25hbWVfcmJfbm9kZSAqdG1wOworCisJCXRtcCA9IHJiX2VudHJ5KG4sIHN0cnVjdCBzeW1ib2xfbmFtZV9yYl9ub2RlLCByYl9ub2RlKTsKKwkJaWYgKHN0cmNtcCh0bXAtPnN5bS5uYW1lLCBzLT5zeW0ubmFtZSkpCisJCQlicmVhazsKKworCQlzID0gdG1wOworCX0KKworCXJldHVybiAmcy0+c3ltOwogfQogCiBzdHJ1Y3Qgc3ltYm9sICpkc29fX2ZpbmRfc3ltYm9sKHN0cnVjdCBkc28gKmRzbywKQEAgLTQzNiw2ICs0NTAsMTcgQEAKIAlyZXR1cm4gc3ltYm9sc19fbmV4dChzeW0pOwogfQogCitzdHJ1Y3Qgc3ltYm9sICpzeW1ib2xfX25leHRfYnlfbmFtZShzdHJ1Y3Qgc3ltYm9sICpzeW0pCit7CisJc3RydWN0IHN5bWJvbF9uYW1lX3JiX25vZGUgKnMgPSBjb250YWluZXJfb2Yoc3ltLCBzdHJ1Y3Qgc3ltYm9sX25hbWVfcmJfbm9kZSwgc3ltKTsKKwlzdHJ1Y3QgcmJfbm9kZSAqbiA9IHJiX25leHQoJnMtPnJiX25vZGUpOworCisJcmV0dXJuIG4gPyAmcmJfZW50cnkobiwgc3RydWN0IHN5bWJvbF9uYW1lX3JiX25vZGUsIHJiX25vZGUpLT5zeW0gOiBOVUxMOworfQorCisgLyoKKyAgKiBUZXR1cm5zIGZpcnN0IHN5bWJvbCB0aGF0IG1hdGNoZWQgd2l0aCBAbmFtZS4KKyAgKi8KIHN0cnVjdCBzeW1ib2wgKmRzb19fZmluZF9zeW1ib2xfYnlfbmFtZShzdHJ1Y3QgZHNvICpkc28sIGVudW0gbWFwX3R5cGUgdHlwZSwKIAkJCQkJY29uc3QgY2hhciAqbmFtZSkKIHsKZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvdXRpbC9zeW1ib2wuaCBiL3Rvb2xzL3BlcmYvdXRpbC9zeW1ib2wuaAppbmRleCA5ZDYwMmU5Li4xNjUwZGNiIDEwMDY0NAotLS0gYS90b29scy9wZXJmL3V0aWwvc3ltYm9sLmgKKysrIGIvdG9vbHMvcGVyZi91dGlsL3N5bWJvbC5oCkBAIC0yMzEsNiArMjMxLDcgQEAKIAkJCQl1NjQgYWRkcik7CiBzdHJ1Y3Qgc3ltYm9sICpkc29fX2ZpbmRfc3ltYm9sX2J5X25hbWUoc3RydWN0IGRzbyAqZHNvLCBlbnVtIG1hcF90eXBlIHR5cGUsCiAJCQkJCWNvbnN0IGNoYXIgKm5hbWUpOworc3RydWN0IHN5bWJvbCAqc3ltYm9sX19uZXh0X2J5X25hbWUoc3RydWN0IHN5bWJvbCAqc3ltKTsKIAogc3RydWN0IHN5bWJvbCAqZHNvX19maXJzdF9zeW1ib2woc3RydWN0IGRzbyAqZHNvLCBlbnVtIG1hcF90eXBlIHR5cGUpOwogc3RydWN0IHN5bWJvbCAqZHNvX19uZXh0X3N5bWJvbChzdHJ1Y3Qgc3ltYm9sICpzeW0pOwpkaWZmIC0tZ2l0IGEvdG9vbHMvcG93ZXIvYWNwaS9jb21tb24vY21mc2l6ZS5jIGIvdG9vbHMvcG93ZXIvYWNwaS9jb21tb24vY21mc2l6ZS5jCmluZGV4IGY0Yjk1MzMuLmVlYzY4ODAgMTAwNjQ0Ci0tLSBhL3Rvb2xzL3Bvd2VyL2FjcGkvY29tbW9uL2NtZnNpemUuYworKysgYi90b29scy9wb3dlci9hY3BpL2NvbW1vbi9jbWZzaXplLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS90b29scy9wb3dlci9hY3BpL2NvbW1vbi9nZXRvcHQuYyBiL3Rvb2xzL3Bvd2VyL2FjcGkvY29tbW9uL2dldG9wdC5jCmluZGV4IDJmMGYzNGEuLjVkYTEyOWUgMTAwNjQ0Ci0tLSBhL3Rvb2xzL3Bvd2VyL2FjcGkvY29tbW9uL2dldG9wdC5jCisrKyBiL3Rvb2xzL3Bvd2VyL2FjcGkvY29tbW9uL2dldG9wdC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvdG9vbHMvcG93ZXIvYWNwaS9vc19zcGVjaWZpYy9zZXJ2aWNlX2xheWVycy9vc2xpYmNmcy5jIGIvdG9vbHMvcG93ZXIvYWNwaS9vc19zcGVjaWZpYy9zZXJ2aWNlX2xheWVycy9vc2xpYmNmcy5jCmluZGV4IGMxM2ZmOWMuLmI1MWU0MGEgMTAwNjQ0Ci0tLSBhL3Rvb2xzL3Bvd2VyL2FjcGkvb3Nfc3BlY2lmaWMvc2VydmljZV9sYXllcnMvb3NsaWJjZnMuYworKysgYi90b29scy9wb3dlci9hY3BpL29zX3NwZWNpZmljL3NlcnZpY2VfbGF5ZXJzL29zbGliY2ZzLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS90b29scy9wb3dlci9hY3BpL29zX3NwZWNpZmljL3NlcnZpY2VfbGF5ZXJzL29zbGludXh0YmwuYyBiL3Rvb2xzL3Bvd2VyL2FjcGkvb3Nfc3BlY2lmaWMvc2VydmljZV9sYXllcnMvb3NsaW51eHRibC5jCmluZGV4IDBkYzI0ODUuLjkyZjFmZDcgMTAwNjQ0Ci0tLSBhL3Rvb2xzL3Bvd2VyL2FjcGkvb3Nfc3BlY2lmaWMvc2VydmljZV9sYXllcnMvb3NsaW51eHRibC5jCisrKyBiL3Rvb2xzL3Bvd2VyL2FjcGkvb3Nfc3BlY2lmaWMvc2VydmljZV9sYXllcnMvb3NsaW51eHRibC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvdG9vbHMvcG93ZXIvYWNwaS9vc19zcGVjaWZpYy9zZXJ2aWNlX2xheWVycy9vc3VuaXhkaXIuYyBiL3Rvb2xzL3Bvd2VyL2FjcGkvb3Nfc3BlY2lmaWMvc2VydmljZV9sYXllcnMvb3N1bml4ZGlyLmMKaW5kZXggNzMzZjllNC4uZTE1M2ZjYiAxMDA2NDQKLS0tIGEvdG9vbHMvcG93ZXIvYWNwaS9vc19zcGVjaWZpYy9zZXJ2aWNlX2xheWVycy9vc3VuaXhkaXIuYworKysgYi90b29scy9wb3dlci9hY3BpL29zX3NwZWNpZmljL3NlcnZpY2VfbGF5ZXJzL29zdW5peGRpci5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvdG9vbHMvcG93ZXIvYWNwaS9vc19zcGVjaWZpYy9zZXJ2aWNlX2xheWVycy9vc3VuaXhtYXAuYyBiL3Rvb2xzL3Bvd2VyL2FjcGkvb3Nfc3BlY2lmaWMvc2VydmljZV9sYXllcnMvb3N1bml4bWFwLmMKaW5kZXggOTliNDdiNi4uMzg1M2E3MyAxMDA2NDQKLS0tIGEvdG9vbHMvcG93ZXIvYWNwaS9vc19zcGVjaWZpYy9zZXJ2aWNlX2xheWVycy9vc3VuaXhtYXAuYworKysgYi90b29scy9wb3dlci9hY3BpL29zX3NwZWNpZmljL3NlcnZpY2VfbGF5ZXJzL29zdW5peG1hcC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvdG9vbHMvcG93ZXIvYWNwaS9vc19zcGVjaWZpYy9zZXJ2aWNlX2xheWVycy9vc3VuaXh4Zi5jIGIvdG9vbHMvcG93ZXIvYWNwaS9vc19zcGVjaWZpYy9zZXJ2aWNlX2xheWVycy9vc3VuaXh4Zi5jCmluZGV4IDdjY2IwNzMuLjY4NThjMDggMTAwNjQ0Ci0tLSBhL3Rvb2xzL3Bvd2VyL2FjcGkvb3Nfc3BlY2lmaWMvc2VydmljZV9sYXllcnMvb3N1bml4eGYuYworKysgYi90b29scy9wb3dlci9hY3BpL29zX3NwZWNpZmljL3NlcnZpY2VfbGF5ZXJzL29zdW5peHhmLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS90b29scy9wb3dlci9hY3BpL3Rvb2xzL2FjcGlkdW1wL2FjcGlkdW1wLmggYi90b29scy9wb3dlci9hY3BpL3Rvb2xzL2FjcGlkdW1wL2FjcGlkdW1wLmgKaW5kZXggYTJkMzdkNi4uODRiZGVmMCAxMDA2NDQKLS0tIGEvdG9vbHMvcG93ZXIvYWNwaS90b29scy9hY3BpZHVtcC9hY3BpZHVtcC5oCisrKyBiL3Rvb2xzL3Bvd2VyL2FjcGkvdG9vbHMvYWNwaWR1bXAvYWNwaWR1bXAuaApAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTQsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE1LCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL3Rvb2xzL3Bvd2VyL2FjcGkvdG9vbHMvYWNwaWR1bXAvYXBkdW1wLmMgYi90b29scy9wb3dlci9hY3BpL3Rvb2xzL2FjcGlkdW1wL2FwZHVtcC5jCmluZGV4IDI0ZDMyOTY4Li5jNzM2YWRmIDEwMDY0NAotLS0gYS90b29scy9wb3dlci9hY3BpL3Rvb2xzL2FjcGlkdW1wL2FwZHVtcC5jCisrKyBiL3Rvb2xzL3Bvd2VyL2FjcGkvdG9vbHMvYWNwaWR1bXAvYXBkdW1wLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDE0LCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS90b29scy9wb3dlci9hY3BpL3Rvb2xzL2FjcGlkdW1wL2FwZmlsZXMuYyBiL3Rvb2xzL3Bvd2VyL2FjcGkvdG9vbHMvYWNwaWR1bXAvYXBmaWxlcy5jCmluZGV4IGQ0NzAwNDYuLjhmMmZlMTYgMTAwNjQ0Ci0tLSBhL3Rvb2xzL3Bvd2VyL2FjcGkvdG9vbHMvYWNwaWR1bXAvYXBmaWxlcy5jCisrKyBiL3Rvb2xzL3Bvd2VyL2FjcGkvdG9vbHMvYWNwaWR1bXAvYXBmaWxlcy5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvdG9vbHMvcG93ZXIvYWNwaS90b29scy9hY3BpZHVtcC9hcG1haW4uYyBiL3Rvb2xzL3Bvd2VyL2FjcGkvdG9vbHMvYWNwaWR1bXAvYXBtYWluLmMKaW5kZXggODUzYjRkYS4uZDBiYTY1MyAxMDA2NDQKLS0tIGEvdG9vbHMvcG93ZXIvYWNwaS90b29scy9hY3BpZHVtcC9hcG1haW4uYworKysgYi90b29scy9wb3dlci9hY3BpL3Rvb2xzL2FjcGlkdW1wL2FwbWFpbi5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxNCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTUsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAo=